Bump version to 0.0.176

Detect unused arguments

.github/workflows/ci.yaml

@@ -20,6 +20,9 @@ jobs:
       - uses: actions-rs/toolchain@v1
         with:
           profile: minimal
+          toolchain: nightly-2022-11-01
+          override: true
+          components: rustfmt
       - uses: actions/cache@v3
         env:
           cache-name: cache-cargo
@@ -33,6 +36,12 @@ jobs:
             ${{ runner.os }}-build-
             ${{ runner.os }}-
       - run: cargo build --all --release
+      - run: ./target/release/ruff_dev generate-rules-table
+      - run: ./target/release/ruff_dev generate-options
+      - run: git diff --quiet README.md || echo "::error file=README.md::This file is outdated. You may have to rerun 'cargo dev generate-options' and/or 'cargo dev generate-rules-table'."
+      - run: ./target/release/ruff_dev generate-check-code-prefix && cargo fmt -- src/checks_gen.rs
+      - run: git diff --quiet src/checks_gen.rs || echo "::error file=src/checks_gen.rs::This file is outdated. You may have to rerun 'cargo dev generate-check-code-prefix'."
+      - run: git diff --exit-code -- README.md src/checks_gen.rs
 
   cargo_fmt:
     name: "cargo fmt"

.github/workflows/ruff.yaml

@@ -1,9 +1,8 @@
 name: "[ruff] Release"
 
 on:
-  create:
-    tags:
-      - v*
+  release:
+    types: [published]
 
 concurrency:
   group: ${{ github.workflow }}-${{ github.ref }}

.pre-commit-config.yaml

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

CONTRIBUTING.md

@@ -105,6 +105,8 @@ You may also want to add the new configuration option to the `flake8-to-ruff` to
 responsible for converting `flake8` configuration files to Ruff's TOML format. This logic
 lives in `flake8_to_ruff/src/converter.rs`.
 
+To update the documentation for supported configuration options, run `cargo dev generate-options`.
+
 ## Release process
 
 As of now, Ruff has an ad hoc release process: releases are cut with high frequency via GitHub

Cargo.lock

@@ -724,7 +724,7 @@ checksum = "0ce7134b9999ecaf8bcd65542e436736ef32ddca1b3e06094cb6ec5755203b80"
 
 [[package]]
 name = "flake8-to-ruff"
-version = "0.0.161-dev.0"
+version = "0.0.176-dev.0"
 dependencies = [
  "anyhow",
  "clap 4.0.29",
@@ -1821,7 +1821,7 @@ dependencies = [
 
 [[package]]
 name = "ruff"
-version = "0.0.161"
+version = "0.0.176"
 dependencies = [
  "annotate-snippets 0.9.1",
  "anyhow",
@@ -1855,6 +1855,7 @@ dependencies = [
  "rayon",
  "regex",
  "ropey",
+ "ruff_macros",
  "rustc-hash",
  "rustpython-ast",
  "rustpython-common",
@@ -1873,7 +1874,7 @@ dependencies = [
 
 [[package]]
 name = "ruff_dev"
-version = "0.0.161"
+version = "0.0.176"
 dependencies = [
  "anyhow",
  "clap 4.0.29",
@@ -1889,6 +1890,16 @@ dependencies = [
  "strum_macros",
 ]
 
+[[package]]
+name = "ruff_macros"
+version = "0.0.176"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+ "textwrap",
+]
+
 [[package]]
 name = "rustc-hash"
 version = "1.1.0"
@@ -1924,7 +1935,7 @@ dependencies = [
 [[package]]
 name = "rustpython-ast"
 version = "0.1.0"
-source = "git+https://github.com/RustPython/RustPython.git?rev=28f9f65ccc625f00835d84bbb5fba274dce5aa89#28f9f65ccc625f00835d84bbb5fba274dce5aa89"
+source = "git+https://github.com/RustPython/RustPython.git?rev=2edd0d264c50c7807bcff03a52a6509e8b7f187f#2edd0d264c50c7807bcff03a52a6509e8b7f187f"
 dependencies = [
  "num-bigint",
  "rustpython-common",
@@ -1934,7 +1945,7 @@ dependencies = [
 [[package]]
 name = "rustpython-common"
 version = "0.0.0"
-source = "git+https://github.com/RustPython/RustPython.git?rev=28f9f65ccc625f00835d84bbb5fba274dce5aa89#28f9f65ccc625f00835d84bbb5fba274dce5aa89"
+source = "git+https://github.com/RustPython/RustPython.git?rev=2edd0d264c50c7807bcff03a52a6509e8b7f187f#2edd0d264c50c7807bcff03a52a6509e8b7f187f"
 dependencies = [
  "ascii",
  "cfg-if 1.0.0",
@@ -1957,7 +1968,7 @@ dependencies = [
 [[package]]
 name = "rustpython-compiler-core"
 version = "0.1.2"
-source = "git+https://github.com/RustPython/RustPython.git?rev=28f9f65ccc625f00835d84bbb5fba274dce5aa89#28f9f65ccc625f00835d84bbb5fba274dce5aa89"
+source = "git+https://github.com/RustPython/RustPython.git?rev=2edd0d264c50c7807bcff03a52a6509e8b7f187f#2edd0d264c50c7807bcff03a52a6509e8b7f187f"
 dependencies = [
  "bincode",
  "bitflags",
@@ -1974,7 +1985,7 @@ dependencies = [
 [[package]]
 name = "rustpython-parser"
 version = "0.1.2"
-source = "git+https://github.com/RustPython/RustPython.git?rev=28f9f65ccc625f00835d84bbb5fba274dce5aa89#28f9f65ccc625f00835d84bbb5fba274dce5aa89"
+source = "git+https://github.com/RustPython/RustPython.git?rev=2edd0d264c50c7807bcff03a52a6509e8b7f187f#2edd0d264c50c7807bcff03a52a6509e8b7f187f"
 dependencies = [
  "ahash",
  "anyhow",

Cargo.toml

@@ -6,7 +6,7 @@ members = [
 
 [package]
 name = "ruff"
-version = "0.0.161"
+version = "0.0.176"
 edition = "2021"
 rust-version = "1.65.0"
 
@@ -41,10 +41,11 @@ 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 }
+ruff_macros = { version = "0.0.176", path = "ruff_macros" }
 rustc-hash = { version = "1.1.0" }
-rustpython-ast = { features = ["unparse"], git = "https://github.com/RustPython/RustPython.git", rev = "28f9f65ccc625f00835d84bbb5fba274dce5aa89" }
-rustpython-common = { git = "https://github.com/RustPython/RustPython.git", rev = "28f9f65ccc625f00835d84bbb5fba274dce5aa89" }
-rustpython-parser = { features = ["lalrpop"], git = "https://github.com/RustPython/RustPython.git", rev = "28f9f65ccc625f00835d84bbb5fba274dce5aa89" }
+rustpython-ast = { features = ["unparse"], git = "https://github.com/RustPython/RustPython.git", rev = "2edd0d264c50c7807bcff03a52a6509e8b7f187f" }
+rustpython-common = { git = "https://github.com/RustPython/RustPython.git", rev = "2edd0d264c50c7807bcff03a52a6509e8b7f187f" }
+rustpython-parser = { features = ["lalrpop"], git = "https://github.com/RustPython/RustPython.git", rev = "2edd0d264c50c7807bcff03a52a6509e8b7f187f" }
 serde = { version = "1.0.147", features = ["derive"] }
 serde_json = { version = "1.0.87" }
 strum = { version = "0.24.1", features = ["strum_macros"] }

LICENSE

@@ -388,6 +388,81 @@ are:
     SOFTWARE.
   """
 
+- flake8-import-conventions, licensed as follows:
+  """
+    MIT License
+
+    Copyright (c) 2021 João Palmeiro
+
+    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-unused-arguments, licensed as follows:
+  """
+    MIT License
+
+    Copyright (c) 2019 Nathan Hoad
+
+    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-simplify, licensed as follows:
+  """
+    MIT License
+
+    Copyright (c) 2020 Martin Thoma
+
+    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.
+  """
+
 - isort, licensed as follows:
   """
     The MIT License (MIT)

create_plugin.sh

@@ -1,11 +0,0 @@
-set -euxo pipefail
-
-NAME=$1
-
-mkdir -p src/$1
-mkdir -p resources/test/fixtures/$1
-touch src/$1/mod.rs
-
-sed -i "" "s/mod flake8_print;/mod flake8_print; mod flake8_return;/g" src/lib.rs
-sed -i "" "s|// flake8-print|// flake8-return\n// flake8-print|g" src/checks.rs
-

flake8_to_ruff/Cargo.lock

@@ -771,7 +771,7 @@ checksum = "0ce7134b9999ecaf8bcd65542e436736ef32ddca1b3e06094cb6ec5755203b80"
 
 [[package]]
 name = "flake8_to_ruff"
-version = "0.0.161"
+version = "0.0.176"
 dependencies = [
  "anyhow",
  "clap",
@@ -1975,7 +1975,7 @@ dependencies = [
 
 [[package]]
 name = "ruff"
-version = "0.0.161"
+version = "0.0.176"
 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=28f9f65ccc625f00835d84bbb5fba274dce5aa89#28f9f65ccc625f00835d84bbb5fba274dce5aa89"
+source = "git+https://github.com/RustPython/RustPython.git?rev=2edd0d264c50c7807bcff03a52a6509e8b7f187f#2edd0d264c50c7807bcff03a52a6509e8b7f187f"
 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=28f9f65ccc625f00835d84bbb5fba274dce5aa89#28f9f65ccc625f00835d84bbb5fba274dce5aa89"
+source = "git+https://github.com/RustPython/RustPython.git?rev=2edd0d264c50c7807bcff03a52a6509e8b7f187f#2edd0d264c50c7807bcff03a52a6509e8b7f187f"
 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=28f9f65ccc625f00835d84bbb5fba274dce5aa89#28f9f65ccc625f00835d84bbb5fba274dce5aa89"
+source = "git+https://github.com/RustPython/RustPython.git?rev=2edd0d264c50c7807bcff03a52a6509e8b7f187f#2edd0d264c50c7807bcff03a52a6509e8b7f187f"
 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=28f9f65ccc625f00835d84bbb5fba274dce5aa89#28f9f65ccc625f00835d84bbb5fba274dce5aa89"
+source = "git+https://github.com/RustPython/RustPython.git?rev=2edd0d264c50c7807bcff03a52a6509e8b7f187f#2edd0d264c50c7807bcff03a52a6509e8b7f187f"
 dependencies = [
  "ahash",
  "anyhow",

flake8_to_ruff/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "flake8-to-ruff"
-version = "0.0.161-dev.0"
+version = "0.0.176-dev.0"
 edition = "2021"
 
 [lib]

flake8_to_ruff/src/converter.rs

@@ -270,6 +270,7 @@ mod tests {
             flake8_bugbear: None,
             flake8_quotes: None,
             flake8_tidy_imports: None,
+            flake8_import_conventions: None,
             isort: None,
             mccabe: None,
             pep8_naming: None,
@@ -314,6 +315,7 @@ mod tests {
             flake8_bugbear: None,
             flake8_quotes: None,
             flake8_tidy_imports: None,
+            flake8_import_conventions: None,
             isort: None,
             mccabe: None,
             pep8_naming: None,
@@ -358,6 +360,7 @@ mod tests {
             flake8_bugbear: None,
             flake8_quotes: None,
             flake8_tidy_imports: None,
+            flake8_import_conventions: None,
             isort: None,
             mccabe: None,
             pep8_naming: None,
@@ -402,6 +405,7 @@ mod tests {
             flake8_bugbear: None,
             flake8_quotes: None,
             flake8_tidy_imports: None,
+            flake8_import_conventions: None,
             isort: None,
             mccabe: None,
             pep8_naming: None,
@@ -451,6 +455,7 @@ mod tests {
                 avoid_escape: None,
             }),
             flake8_tidy_imports: None,
+            flake8_import_conventions: None,
             isort: None,
             mccabe: None,
             pep8_naming: None,
@@ -507,6 +512,7 @@ mod tests {
                 CheckCodePrefix::D214,
                 CheckCodePrefix::D215,
                 CheckCodePrefix::D300,
+                CheckCodePrefix::D301,
                 CheckCodePrefix::D400,
                 CheckCodePrefix::D403,
                 CheckCodePrefix::D404,
@@ -533,6 +539,7 @@ mod tests {
             flake8_bugbear: None,
             flake8_quotes: None,
             flake8_tidy_imports: None,
+            flake8_import_conventions: None,
             isort: None,
             mccabe: None,
             pep8_naming: None,
@@ -583,6 +590,7 @@ mod tests {
                 avoid_escape: None,
             }),
             flake8_tidy_imports: None,
+            flake8_import_conventions: None,
             isort: None,
             mccabe: None,
             pep8_naming: None,

flake8_to_ruff/src/parser.rs

@@ -135,7 +135,6 @@ fn tokenize_files_to_codes_mapping(value: &str) -> Vec<Token> {
 }
 
 /// Parse a 'files-to-codes' mapping, mimicking Flake8's internal logic.
-///
 /// See: <https://github.com/PyCQA/flake8/blob/7dfe99616fc2f07c0017df2ba5fa884158f3ea8a/src/flake8/utils.py#L45>
 pub fn parse_files_to_codes_mapping(value: &str) -> Result<Vec<PatternPrefixPair>> {
     if value.trim().is_empty() {

flake8_to_ruff/src/plugin.rs

@@ -18,6 +18,7 @@ pub enum Plugin {
     Flake8Print,
     Flake8Quotes,
     Flake8Return,
+    Flake8Simplify,
     Flake8TidyImports,
     McCabe,
     PEP8Naming,
@@ -41,6 +42,7 @@ impl FromStr for Plugin {
             "flake8-print" => Ok(Plugin::Flake8Print),
             "flake8-quotes" => Ok(Plugin::Flake8Quotes),
             "flake8-return" => Ok(Plugin::Flake8Return),
+            "flake8-simplify" => Ok(Plugin::Flake8Simplify),
             "flake8-tidy-imports" => Ok(Plugin::Flake8TidyImports),
             "mccabe" => Ok(Plugin::McCabe),
             "pep8-naming" => Ok(Plugin::PEP8Naming),
@@ -65,6 +67,7 @@ impl Plugin {
             Plugin::Flake8Print => CheckCodePrefix::T2,
             Plugin::Flake8Quotes => CheckCodePrefix::Q,
             Plugin::Flake8Return => CheckCodePrefix::RET,
+            Plugin::Flake8Simplify => CheckCodePrefix::SIM,
             Plugin::Flake8TidyImports => CheckCodePrefix::I25,
             Plugin::McCabe => CheckCodePrefix::C9,
             Plugin::PEP8Naming => CheckCodePrefix::N,
@@ -101,6 +104,7 @@ impl Plugin {
             Plugin::Flake8Print => vec![CheckCodePrefix::T2],
             Plugin::Flake8Quotes => vec![CheckCodePrefix::Q],
             Plugin::Flake8Return => vec![CheckCodePrefix::RET],
+            Plugin::Flake8Simplify => vec![CheckCodePrefix::SIM],
             Plugin::Flake8TidyImports => vec![CheckCodePrefix::I25],
             Plugin::McCabe => vec![CheckCodePrefix::C9],
             Plugin::PEP8Naming => vec![CheckCodePrefix::N],
@@ -162,6 +166,7 @@ impl DocstringConvention {
                 // CheckCodePrefix::D214,
                 // CheckCodePrefix::D215,
                 CheckCodePrefix::D300,
+                CheckCodePrefix::D301,
                 CheckCodePrefix::D400,
                 CheckCodePrefix::D402,
                 CheckCodePrefix::D403,
@@ -209,6 +214,7 @@ impl DocstringConvention {
                 CheckCodePrefix::D214,
                 CheckCodePrefix::D215,
                 CheckCodePrefix::D300,
+                CheckCodePrefix::D301,
                 CheckCodePrefix::D400,
                 // CheckCodePrefix::D402,
                 CheckCodePrefix::D403,
@@ -257,6 +263,7 @@ impl DocstringConvention {
                 CheckCodePrefix::D214,
                 // CheckCodePrefix::D215,
                 CheckCodePrefix::D300,
+                CheckCodePrefix::D301,
                 // CheckCodePrefix::D400,
                 CheckCodePrefix::D402,
                 CheckCodePrefix::D403,
@@ -394,6 +401,7 @@ pub fn infer_plugins_from_codes(codes: &BTreeSet<CheckCodePrefix>) -> Vec<Plugin
         Plugin::Flake8Print,
         Plugin::Flake8Quotes,
         Plugin::Flake8Return,
+        Plugin::Flake8Simplify,
         Plugin::Flake8TidyImports,
         Plugin::PEP8Naming,
         Plugin::Pyupgrade,

resources/test/fixtures/eradicate/ERA001.py

@@ -5,9 +5,11 @@ a = 4
 #foo(1, 2, 3)
 
 def foo(x, y, z):
-    contentet = 1 # print('hello')
+    content = 1 # print('hello')
     print(x, y, z)
 
     # This is a real comment.
     #return True
     return False
+
+#import os  # noqa: ERA001

resources/test/fixtures/flake8_annotations/allow_overload.py

@@ -0,0 +1,49 @@
+from typing import overload
+
+
+@overload
+def foo(i: int) -> "int":
+    ...
+
+
+@overload
+def foo(i: "str") -> "str":
+    ...
+
+
+def foo(i):
+    return i
+
+
+@overload
+def bar(i: int) -> "int":
+    ...
+
+
+@overload
+def bar(i: "str") -> "str":
+    ...
+
+
+class X:
+    def bar(i):
+        return i
+
+
+# TODO(charlie): This third case should raise an error (as in Mypy), because we have a
+# statement between the interfaces and implementation.
+@overload
+def baz(i: int) -> "int":
+    ...
+
+
+@overload
+def baz(i: "str") -> "str":
+    ...
+
+
+x = 1
+
+
+def baz(i):
+    return i

resources/test/fixtures/flake8_blind_except/BLE.py

@@ -53,3 +53,11 @@ try:
         raise e
 except Exception:
     pass
+
+
+try:
+    pass
+except Exception as e:
+    raise bad
+except BaseException:
+    pass

resources/test/fixtures/flake8_bugbear/B905.py

@@ -0,0 +1,10 @@
+zip()
+zip(range(3))
+zip("a", "b")
+zip("a", "b", *zip("c"))
+zip(zip("a"), strict=False)
+zip(zip("a", strict=True))
+
+zip(range(3), strict=True)
+zip("a", "b", strict=False)
+zip("a", "b", "c", strict=True)

resources/test/fixtures/flake8_import_conventions/custom.py

@@ -0,0 +1,25 @@
+import math  # not checked
+
+import altair  # unconventional
+import dask.array  # unconventional
+import dask.dataframe  # unconventional
+import matplotlib.pyplot  # unconventional
+import numpy  # unconventional
+import pandas  # unconventional
+import seaborn  # unconventional
+
+import altair as altr  # unconventional
+import matplotlib.pyplot as plot  # unconventional
+import dask.array as darray  # unconventional
+import dask.dataframe as ddf  # unconventional
+import numpy as nmp  # unconventional
+import pandas as pdas  # unconventional
+import seaborn as sbrn  # unconventional
+
+import altair as alt  # conventional
+import dask.array as da  # conventional
+import dask.dataframe as dd  # conventional
+import matplotlib.pyplot as plt  # conventional
+import numpy as np  # conventional
+import pandas as pd  # conventional
+import seaborn as sns  # conventional

resources/test/fixtures/flake8_import_conventions/defaults.py

@@ -0,0 +1,19 @@
+import math  # not checked
+
+import altair  # unconventional
+import matplotlib.pyplot  # unconventional
+import numpy  # unconventional
+import pandas  # unconventional
+import seaborn  # unconventional
+
+import altair as altr  # unconventional
+import matplotlib.pyplot as plot  # unconventional
+import numpy as nmp  # unconventional
+import pandas as pdas  # unconventional
+import seaborn as sbrn  # unconventional
+
+import altair as alt  # conventional
+import matplotlib.pyplot as plt  # conventional
+import numpy as np  # conventional
+import pandas as pd  # conventional
+import seaborn as sns  # conventional

resources/test/fixtures/flake8_import_conventions/override_default.py

@@ -0,0 +1,19 @@
+import math  # not checked
+
+import altair  # unconventional
+import matplotlib.pyplot  # unconventional
+import numpy  # unconventional
+import pandas  # unconventional
+import seaborn  # unconventional
+
+import altair as altr  # unconventional
+import matplotlib.pyplot as plot  # unconventional
+import numpy as np  # unconventional
+import pandas as pdas  # unconventional
+import seaborn as sbrn  # unconventional
+
+import altair as alt  # conventional
+import matplotlib.pyplot as plt  # conventional
+import numpy as nmp  # conventional
+import pandas as pd  # conventional
+import seaborn as sns  # conventional

resources/test/fixtures/flake8_import_conventions/remove_default.py

@@ -0,0 +1,19 @@
+import math  # not checked
+
+import altair  # unconventional
+import matplotlib.pyplot  # unconventional
+import numpy  # not checked
+import pandas  # unconventional
+import seaborn  # unconventional
+
+import altair as altr  # unconventional
+import matplotlib.pyplot as plot  # unconventional
+import numpy as nmp  # not checked
+import pandas as pdas  # unconventional
+import seaborn as sbrn  # unconventional
+
+import altair as alt  # conventional
+import matplotlib.pyplot as plt  # conventional
+import numpy as np  # not checked
+import pandas as pd  # conventional
+import seaborn as sns  # conventional

resources/test/fixtures/flake8_return/RET504.py

@@ -130,6 +130,12 @@ def x():
     return val
 
 
+def x():
+    a = 1
+    print(f"a={a}")
+    return a
+
+
 # Test cases for using value for assignment then returning it
 # See:https://github.com/afonasev/flake8-return/issues/47
 def resolve_from_url(self, url: str) -> dict:

resources/test/fixtures/flake8_simplify/SIM118.py

@@ -0,0 +1,12 @@
+key in dict.keys() # SIM118
+
+foo["bar"] in dict.keys() # SIM118
+
+foo() in dict.keys() # SIM118
+
+for key in dict.keys(): # SIM118
+    pass
+
+for key in list(dict.keys()):
+    if some_property(key):
+        del dict[key]

resources/test/fixtures/flake8_unused_arguments/ARG.py

@@ -0,0 +1,137 @@
+from abc import abstractmethod
+from typing_extensions import override
+
+
+###
+# Unused arguments on functions.
+###
+def f(self, x):
+    print("Hello, world!")
+
+
+def f(cls, x):
+    print("Hello, world!")
+
+
+def f(self, x):
+    ...
+
+
+def f(cls, x):
+    ...
+
+
+###
+# Unused arguments on lambdas.
+###
+lambda x: print("Hello, world!")
+
+
+class X:
+    ###
+    # Unused arguments.
+    ###
+    def f(self, x):
+        print("Hello, world!")
+
+    def f(self, /, x):
+        print("Hello, world!")
+
+    def f(cls, x):
+        print("Hello, world!")
+
+    @classmethod
+    def f(cls, x):
+        print("Hello, world!")
+
+    @staticmethod
+    def f(cls, x):
+        print("Hello, world!")
+
+    @staticmethod
+    def f(x):
+        print("Hello, world!")
+
+    ###
+    # Unused arguments attached to empty functions (OK).
+    ###
+    def f(self, x):
+        ...
+
+    def f(self, /, x):
+        ...
+
+    def f(cls, x):
+        ...
+
+    @classmethod
+    def f(cls, x):
+        ...
+
+    @staticmethod
+    def f(cls, x):
+        ...
+
+    @staticmethod
+    def f(x):
+        ...
+
+    ###
+    # Unused functions attached to abstract methods (OK).
+    ###
+    @abstractmethod
+    def f(self, x):
+        print("Hello, world!")
+
+    @abstractmethod
+    def f(self, /, x):
+        print("Hello, world!")
+
+    @abstractmethod
+    def f(cls, x):
+        print("Hello, world!")
+
+    @classmethod
+    @abstractmethod
+    def f(cls, x):
+        print("Hello, world!")
+
+    @staticmethod
+    @abstractmethod
+    def f(cls, x):
+        print("Hello, world!")
+
+    @staticmethod
+    @abstractmethod
+    def f(x):
+        print("Hello, world!")
+
+    ###
+    # Unused functions attached to overrides (OK).
+    ###
+    @override
+    def f(self, x):
+        print("Hello, world!")
+
+    @override
+    def f(self, /, x):
+        print("Hello, world!")
+
+    @override
+    def f(cls, x):
+        print("Hello, world!")
+
+    @classmethod
+    @override
+    def f(cls, x):
+        print("Hello, world!")
+
+    @staticmethod
+    @override
+    def f(cls, x):
+        print("Hello, world!")
+
+    @staticmethod
+    @override
+    def f(x):
+        print("Hello, world!")

resources/test/fixtures/isort/insert_empty_lines.py

@@ -14,3 +14,28 @@ y = 1
 import os
 import sys
 """Docstring"""
+
+if True:
+    import os
+
+
+def f():
+    pass
+
+
+if True:
+    import os
+def f():
+    pass
+
+if True:
+    x = 1
+    import collections
+    import typing
+    class X: pass
+
+if True:
+    x = 1
+    import collections
+    import typing
+    def f(): pass

resources/test/fixtures/isort/insert_empty_lines.pyi

@@ -0,0 +1,41 @@
+import a
+import b
+x = 1
+import os
+import sys
+def f():
+    pass
+if True:
+    x = 1
+    import collections
+    import typing
+class X: pass
+y = 1
+import os
+import sys
+"""Docstring"""
+
+if True:
+    import os
+
+
+def f():
+    pass
+
+
+if True:
+    import os
+def f():
+    pass
+
+if True:
+    x = 1
+    import collections
+    import typing
+    class X: pass
+
+if True:
+    x = 1
+    import collections
+    import typing
+    def f(): pass

resources/test/fixtures/isort/no_wrap_star.py

@@ -0,0 +1 @@
+from .subscription import * # type: ignore  # some very long comment explaining why this needs a type ignore

resources/test/fixtures/pydocstyle/D.py

@@ -571,3 +571,11 @@ def multiline_trailing_and_leading_space():
     """
 
     pass
+
+
+@expect('D210: No whitespaces allowed surrounding docstring text')
+@expect("D400: First line should end with a period (not '\"')")
+@expect("D415: First line should end with a period, question mark, "
+        "or exclamation point (not '\"')")
+def endswith_quote():
+    """Whitespace at the end, but also a quote" """

resources/test/fixtures/pydocstyle/D400.py

@@ -0,0 +1,73 @@
+def f():
+    "Here's a line without a period"
+    ...
+
+
+def f():
+    """Here's a line without a period"""
+    ...
+
+
+def f():
+    """
+    Here's a line without a period,
+    but here's the next line
+    """
+    ...
+
+
+def f():
+    """Here's a line without a period"""
+    ...
+
+
+def f():
+    """
+    Here's a line without a period,
+    but here's the next line"""
+    ...
+
+
+def f():
+    """
+    Here's a line without a period,
+    but here's the next line with trailing space """
+    ...
+
+
+
+def f():
+    r"Here's a line without a period"
+    ...
+
+
+def f():
+    r"""Here's a line without a period"""
+    ...
+
+
+def f():
+    r"""
+    Here's a line without a period,
+    but here's the next line
+    """
+    ...
+
+
+def f():
+    r"""Here's a line without a period"""
+    ...
+
+
+def f():
+    r"""
+    Here's a line without a period,
+    but here's the next line"""
+    ...
+
+
+def f():
+    r"""
+    Here's a line without a period,
+    but here's the next line with trailing space """
+    ...

resources/test/fixtures/pyflakes/F504.py

@@ -4,3 +4,6 @@ a = "wrong"
 
 hidden = {"a": "!"}
 "%(a)s %(c)s" % {"x": 1, **hidden}  # Ok (cannot see through splat)
+
+"%(a)s" % {"a": 1, r"b": "!"}  # F504 ("b" not used)
+"%(a)s" % {'a': 1, u"b": "!"}  # F504 ("b" not used)

resources/test/fixtures/pyflakes/F541.py

@@ -9,3 +9,4 @@ e = (
 )
 
 g = f"ghi{123:{45}}"
+h = "x" "y" f"z"

resources/test/fixtures/pyflakes/F811_0.py

@@ -0,0 +1,11 @@
+def foo(x):
+    return x
+
+
+@foo
+def bar():
+    pass
+
+
+def bar():
+    pass

resources/test/fixtures/pyflakes/F811_1.py

@@ -0,0 +1 @@
+import fu as FU, bar as FU

resources/test/fixtures/pyflakes/F811_10.py

@@ -0,0 +1,8 @@
+"""Test that importing a module twice using a nested does not issue a warning."""
+try:
+    if True:
+        if True:
+            import os
+except:
+    import os
+os.path

resources/test/fixtures/pyflakes/F811_11.py

@@ -0,0 +1,9 @@
+try:
+    from aa import mixer
+except AttributeError:
+    from bb import mixer
+except RuntimeError:
+    from cc import mixer
+except:
+    from dd import mixer
+mixer(123)

resources/test/fixtures/pyflakes/F811_12.py

@@ -0,0 +1,7 @@
+try:
+    from aa import mixer
+except ImportError:
+    pass
+else:
+    from bb import mixer
+mixer(123)

resources/test/fixtures/pyflakes/F811_13.py

@@ -0,0 +1,8 @@
+try:
+    import funca
+except ImportError:
+    from bb import funca
+    from bb import funcb
+else:
+    from bbb import funcb
+print(funca, funcb)

resources/test/fixtures/pyflakes/F811_14.py

@@ -0,0 +1,10 @@
+try:
+    import b
+except ImportError:
+    b = Ellipsis
+    from bb import a
+else:
+    from aa import a
+finally:
+    a = 42
+print(a, b)

resources/test/fixtures/pyflakes/F811_15.py

@@ -0,0 +1,5 @@
+import fu
+
+
+def fu():
+    pass

resources/test/fixtures/pyflakes/F811_16.py

@@ -0,0 +1,9 @@
+"""Test that shadowing a global with a nested function generates a warning."""
+
+import fu
+
+
+def bar():
+    def baz():
+        def fu():
+            pass

resources/test/fixtures/pyflakes/F811_17.py

@@ -0,0 +1,10 @@
+"""Test that shadowing a global name with a nested function generates a warning."""
+import fu
+
+
+def bar():
+    import fu
+
+    def baz():
+        def fu():
+            pass

resources/test/fixtures/pyflakes/F811_18.py

@@ -0,0 +1,14 @@
+"""Test that a global import which is redefined locally, but used later in another scope does not generate a warning."""
+
+import unittest, transport
+
+
+class GetTransportTestCase(unittest.TestCase):
+    def test_get_transport(self):
+        transport = 'transport'
+        self.assertIsNotNone(transport)
+
+
+class TestTransportMethodArgs(unittest.TestCase):
+    def test_send_defaults(self):
+        transport.Transport()

resources/test/fixtures/pyflakes/F811_19.py

@@ -0,0 +1,7 @@
+"""If an imported name is redefined by a class statement which also uses that name in the bases list, no warning is emitted."""
+
+from fu import bar
+
+
+class bar(bar):
+    pass

resources/test/fixtures/pyflakes/F811_2.py

@@ -0,0 +1 @@
+from moo import fu as FU, bar as FU

resources/test/fixtures/pyflakes/F811_20.py

@@ -0,0 +1,14 @@
+"""
+ Test that shadowing a global with a class attribute does not produce a
+ warning.
+ """
+
+import fu
+
+
+class bar:
+    # STOPSHIP: This errors.
+    fu = 1
+
+
+print(fu)

resources/test/fixtures/pyflakes/F811_3.py

@@ -0,0 +1 @@
+import fu; fu = 3

resources/test/fixtures/pyflakes/F811_4.py

@@ -0,0 +1 @@
+import fu; fu, bar = 3

resources/test/fixtures/pyflakes/F811_5.py

@@ -0,0 +1 @@
+import fu; [fu, bar] = 3

resources/test/fixtures/pyflakes/F811_6.py

@@ -0,0 +1,7 @@
+"""Test that importing a module twice within an if block does raise a warning."""
+
+i = 2
+if i == 1:
+    import os
+    import os
+os.path

resources/test/fixtures/pyflakes/F811_7.py

@@ -0,0 +1,8 @@
+"""Test that importing a module twice in if-else blocks does not raise a warning."""
+
+i = 2
+if i == 1:
+    import os
+else:
+    import os
+os.path

resources/test/fixtures/pyflakes/F811_8.py

@@ -0,0 +1,8 @@
+"""Test that importing a module twice in a try block does raise a warning."""
+
+try:
+    import os
+    import os
+except:
+    pass
+os.path

resources/test/fixtures/pyflakes/F811_9.py

@@ -0,0 +1,7 @@
+"""Test that importing a module twice in a try block does not raise a warning."""
+
+try:
+    import os
+except:
+    import os
+os.path

resources/test/fixtures/pyflakes/F821_6.py

@@ -0,0 +1,17 @@
+"""Test: annotated global."""
+
+
+n: int
+
+
+def f():
+    print(n)
+
+
+def g():
+    global n
+    n = 1
+
+
+g()
+f()

resources/test/fixtures/pyflakes/F841_0.py

@@ -65,3 +65,8 @@ def f7():
 
     with connect() as (connection, cursor):
         cursor.execute("SELECT * FROM users")
+
+
+def f8():
+    with open("file") as f, open("") as ((a, b)):
+        print("hello")

resources/test/fixtures/pyflakes/F841_1.py

@@ -0,0 +1,24 @@
+def f(tup):
+    x, y = tup  # this does NOT trigger F841
+
+
+def f():
+    x, y = 1, 2  # this triggers F841 as it's just a simple assignment where unpacking isn't needed
+
+
+def f():
+    (x, y) = coords = 1, 2  # this does NOT trigger F841
+    if x > 1:
+        print(coords)
+
+
+def f():
+    (x, y) = coords = 1, 2  # this triggers F841 on coords
+
+
+def f():
+    coords = (x, y) = 1, 2  # this triggers F841 on coords
+
+
+def f():
+    (a, b) = (x, y) = 1, 2  # this triggers F841 on everything

resources/test/fixtures/pyflakes/F842.py

@@ -0,0 +1,13 @@
+def f():
+    name: str
+    age: int
+
+
+class A:
+    name: str
+    age: int
+
+
+class B:
+    name: str = "Bob"
+    age: int = 18

resources/test/fixtures/pylint/global_variable_not_assigned.py

@@ -0,0 +1,32 @@
+###
+# Errors.
+###
+def f():
+    global x
+
+
+def f():
+    global x
+
+    print(x)
+
+
+###
+# Non-errors.
+###
+def f():
+    global x
+
+    x = 1
+
+
+def f():
+    global x
+
+    (x, y) = (1, 2)
+
+
+def f():
+    global x
+
+    del x

resources/test/fixtures/pylint/nonlocal_without_binding.py

@@ -0,0 +1,19 @@
+nonlocal x
+
+
+def f():
+    nonlocal x
+
+
+def f():
+    nonlocal y
+
+
+def f():
+    x = 1
+
+    def f():
+        nonlocal x
+
+    def f():
+        nonlocal y

resources/test/fixtures/pylint/used_prior_global_declaration.py

@@ -0,0 +1,148 @@
+###
+# Errors.
+###
+def f():
+    print(x)
+
+    global x
+
+    print(x)
+
+
+def f():
+    global x
+
+    print(x)
+
+    global x
+
+    print(x)
+
+
+def f():
+    print(x)
+
+    global x, y
+
+    print(x)
+
+
+def f():
+    global x, y
+
+    print(x)
+
+    global x, y
+
+    print(x)
+
+
+def f():
+    x = 1
+
+    global x
+
+    x = 1
+
+
+def f():
+    global x
+
+    x = 1
+
+    global x
+
+    x = 1
+
+
+def f():
+    del x
+
+    global x, y
+
+    del x
+
+
+def f():
+    global x, y
+
+    del x
+
+    global x, y
+
+    del x
+
+
+def f():
+    del x
+
+    global x
+
+    del x
+
+
+def f():
+    global x
+
+    del x
+
+    global x
+
+    del x
+
+
+def f():
+    del x
+
+    global x, y
+
+    del x
+
+
+def f():
+    global x, y
+
+    del x
+
+    global x, y
+
+    del x
+
+
+###
+# Non-errors.
+###
+def f():
+    global x
+
+    print(x)
+
+
+def f():
+    global x, y
+
+    print(x)
+
+
+def f():
+    global x
+
+    x = 1
+
+
+def f():
+    global x, y
+
+    x = 1
+
+
+def f():
+    global x
+
+    del x
+
+
+def f():
+    global x, y
+
+    del x

resources/test/fixtures/pylint/useless_else_on_loop.py

@@ -75,7 +75,7 @@ def test_break_in_orelse_deep():
 
 
 def test_break_in_orelse_deep2():
-    """should rise a useless-else-on-loop message, as the break statement is only
+    """should raise a useless-else-on-loop message, as the break statement is only
     for the inner for loop
     """
     for _ in range(10):
@@ -101,3 +101,15 @@ def test_break_in_orelse_deep3():
     else:
         return True
     return False
+
+
+def test_break_in_if_orelse():
+    """should raise a useless-else-on-loop message due to break in else"""
+    for _ in range(10):
+        if 1 < 2:  # pylint: disable=comparison-of-constants
+            pass
+        else:
+            break
+    else:
+        return True
+    return False

resources/test/fixtures/pyproject.toml

@@ -41,3 +41,9 @@ staticmethod-decorators = ["staticmethod"]
 
 [tool.ruff.flake8-tidy-imports]
 ban-relative-imports = "parents"
+
+[tool.ruff.flake8-import-conventions.aliases]
+pandas = "pd"
+
+[tool.ruff.flake8-import-conventions.extend-aliases]
+"dask.dataframe" = "dd"

ruff_dev/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ruff_dev"
-version = "0.0.161"
+version = "0.0.176"
 edition = "2021"
 
 [dependencies]
@@ -11,8 +11,8 @@ itertools = { version = "0.10.5" }
 libcst = { git = "https://github.com/charliermarsh/LibCST", rev = "f2f0b7a487a8725d161fe8b3ed73a6758b21e177" }
 once_cell = { version = "1.16.0" }
 ruff = { path = ".." }
-rustpython-ast = { features = ["unparse"], git = "https://github.com/RustPython/RustPython.git", rev = "28f9f65ccc625f00835d84bbb5fba274dce5aa89" }
-rustpython-common = { git = "https://github.com/RustPython/RustPython.git", rev = "28f9f65ccc625f00835d84bbb5fba274dce5aa89" }
-rustpython-parser = { features = ["lalrpop"], git = "https://github.com/RustPython/RustPython.git", rev = "28f9f65ccc625f00835d84bbb5fba274dce5aa89" }
+rustpython-ast = { features = ["unparse"], git = "https://github.com/RustPython/RustPython.git", rev = "2edd0d264c50c7807bcff03a52a6509e8b7f187f" }
+rustpython-common = { git = "https://github.com/RustPython/RustPython.git", rev = "2edd0d264c50c7807bcff03a52a6509e8b7f187f" }
+rustpython-parser = { features = ["lalrpop"], git = "https://github.com/RustPython/RustPython.git", rev = "2edd0d264c50c7807bcff03a52a6509e8b7f187f" }
 strum = { version = "0.24.1", features = ["strum_macros"] }
 strum_macros = { version = "0.24.3" }

ruff_dev/src/generate_check_code_prefix.rs

@@ -8,7 +8,7 @@ use anyhow::Result;
 use clap::Parser;
 use codegen::{Scope, Type, Variant};
 use itertools::Itertools;
-use ruff::checks::{CheckCode, REDIRECTS};
+use ruff::checks::{CheckCode, CODE_REDIRECTS, PREFIX_REDIRECTS};
 use strum::IntoEnumIterator;
 
 const FILE: &str = "src/checks_gen.rs";
@@ -39,34 +39,26 @@ pub fn main(cli: &Cli) -> Result<()> {
         }
     }
 
-    // Add any aliases (e.g., "U001" to "UP001").
-    for (alias, check_code) in REDIRECTS.iter() {
-        // Compute the length of the prefix and suffix for both codes.
-        let code_str: String = check_code.as_ref().to_string();
-        let code_prefix_len = code_str
-            .chars()
-            .take_while(|char| char.is_alphabetic())
-            .count();
-        let code_suffix_len = code_str.len() - code_prefix_len;
-        let alias_prefix_len = alias
-            .chars()
-            .take_while(|char| char.is_alphabetic())
-            .count();
-        let alias_suffix_len = alias.len() - alias_prefix_len;
-        assert_eq!(code_suffix_len, alias_suffix_len);
-        for i in 0..=code_suffix_len {
-            let source = code_str[..code_prefix_len + i].to_string();
-            let destination = alias[..alias_prefix_len + i].to_string();
-            if source != destination {
-                prefix_to_codes.insert(
-                    destination,
-                    prefix_to_codes
-                        .get(&source)
-                        .unwrap_or_else(|| panic!("Unknown CheckCode: {source:?}"))
-                        .clone(),
-                );
-            }
-        }
+    // Add any prefix aliases (e.g., "U" to "UP").
+    for (alias, source) in PREFIX_REDIRECTS.iter() {
+        prefix_to_codes.insert(
+            (*alias).to_string(),
+            prefix_to_codes
+                .get(&(*source).to_string())
+                .unwrap_or_else(|| panic!("Unknown CheckCode: {source:?}"))
+                .clone(),
+        );
+    }
+
+    // Add any check code aliases (e.g., "U001" to "UP001").
+    for (alias, check_code) in CODE_REDIRECTS.iter() {
+        prefix_to_codes.insert(
+            (*alias).to_string(),
+            prefix_to_codes
+                .get(&check_code.as_ref().to_string())
+                .unwrap_or_else(|| panic!("Unknown CheckCode: {alias:?}"))
+                .clone(),
+        );
     }
 
     let mut scope = Scope::new();
@@ -76,6 +68,7 @@ pub fn main(cli: &Cli) -> Result<()> {
         .new_enum("CheckCodePrefix")
         .vis("pub")
         .derive("EnumString")
+        .derive("AsRefStr")
         .derive("Debug")
         .derive("PartialEq")
         .derive("Eq")
@@ -112,10 +105,10 @@ pub fn main(cli: &Cli) -> Result<()> {
         .line("#[allow(clippy::match_same_arms)]")
         .line("match self {");
     for (prefix, codes) in &prefix_to_codes {
-        if let Some(target) = REDIRECTS.get(&prefix.as_str()) {
+        if let Some(target) = CODE_REDIRECTS.get(&prefix.as_str()) {
             gen = gen.line(format!(
                 "CheckCodePrefix::{prefix} => {{ eprintln!(\"{{}}{{}} {{}}\", \
-                 \"warning\".yellow().bold(), \":\".bold(), \"`{}` has been renamed to \
+                 \"warning\".yellow().bold(), \":\".bold(), \"`{}` has been remapped to \
                  `{}`\".bold()); \n vec![{}] }}",
                 prefix,
                 target.as_ref(),
@@ -124,6 +117,18 @@ pub fn main(cli: &Cli) -> Result<()> {
                     .map(|code| format!("CheckCode::{}", code.as_ref()))
                     .join(", ")
             ));
+        } else if let Some(target) = PREFIX_REDIRECTS.get(&prefix.as_str()) {
+            gen = gen.line(format!(
+                "CheckCodePrefix::{prefix} => {{ eprintln!(\"{{}}{{}} {{}}\", \
+                 \"warning\".yellow().bold(), \":\".bold(), \"`{}` has been remapped to \
+                 `{}`\".bold()); \n vec![{}] }}",
+                prefix,
+                target,
+                codes
+                    .iter()
+                    .map(|code| format!("CheckCode::{}", code.as_ref()))
+                    .join(", ")
+            ));
         } else {
             gen = gen.line(format!(
                 "CheckCodePrefix::{prefix} => vec![{}],",
@@ -170,9 +175,9 @@ pub fn main(cli: &Cli) -> Result<()> {
     output.push('\n');
     output.push_str("use colored::Colorize;");
     output.push('\n');
-    output.push_str("use serde::{{Serialize, Deserialize}};");
+    output.push_str("use serde::{Deserialize, Serialize};");
     output.push('\n');
-    output.push_str("use strum_macros::EnumString;");
+    output.push_str("use strum_macros::{AsRefStr, EnumString};");
     output.push('\n');
     output.push('\n');
     output.push_str("use crate::checks::CheckCode;");
@@ -186,7 +191,9 @@ pub fn main(cli: &Cli) -> Result<()> {
     output.push_str("pub const CATEGORIES: &[CheckCodePrefix] = &[");
     output.push('\n');
     for prefix in prefix_to_codes.keys() {
-        if prefix.chars().all(char::is_alphabetic) {
+        if prefix.chars().all(char::is_alphabetic)
+            && !PREFIX_REDIRECTS.contains_key(&prefix.as_str())
+        {
             output.push_str(&format!("CheckCodePrefix::{prefix},"));
             output.push('\n');
         }

ruff_dev/src/generate_options.rs

@@ -0,0 +1,125 @@
+//! Generate a Markdown-compatible listing of configuration options.
+
+use std::fs;
+use std::fs::OpenOptions;
+use std::io::Write;
+use std::path::PathBuf;
+
+use anyhow::Result;
+use clap::Args;
+use itertools::Itertools;
+use ruff::settings::options::Options;
+use ruff::settings::options_base::{ConfigurationOptions, OptionEntry, OptionField};
+
+const BEGIN_PRAGMA: &str = "<!-- Begin auto-generated options sections. -->";
+const END_PRAGMA: &str = "<!-- End auto-generated options sections. -->";
+
+#[derive(Args)]
+pub struct Cli {
+    /// Write the generated table to stdout (rather than to `README.md`).
+    #[arg(long)]
+    dry_run: bool,
+}
+
+fn emit_field(output: &mut String, field: &OptionField, group_name: Option<&str>) {
+    output.push_str(&format!("#### [`{0}`](#{0})\n", field.name));
+    output.push('\n');
+    output.push_str(field.doc);
+    output.push_str("\n\n");
+    output.push_str(&format!("**Default value**: `{}`\n", field.default));
+    output.push('\n');
+    output.push_str(&format!("**Type**: `{}`\n", field.value_type));
+    output.push('\n');
+    output.push_str(&format!(
+        "**Example usage**:\n\n```toml\n[tool.ruff{}]\n{}\n```\n",
+        if group_name.is_some() {
+            format!(".{}", group_name.unwrap())
+        } else {
+            String::new()
+        },
+        field.example
+    ));
+    output.push('\n');
+}
+
+pub fn main(cli: &Cli) -> Result<()> {
+    let mut output = String::new();
+
+    // Generate all the top-level fields.
+    for field in Options::get_available_options()
+        .into_iter()
+        .filter_map(|entry| {
+            if let OptionEntry::Field(field) = entry {
+                Some(field)
+            } else {
+                None
+            }
+        })
+        .sorted_by_key(|field| field.name)
+    {
+        emit_field(&mut output, &field, None);
+        output.push_str("---\n\n");
+    }
+
+    // Generate all the sub-groups.
+    for group in Options::get_available_options()
+        .into_iter()
+        .filter_map(|entry| {
+            if let OptionEntry::Group(group) = entry {
+                Some(group)
+            } else {
+                None
+            }
+        })
+        .sorted_by_key(|group| group.name)
+    {
+        output.push_str(&format!("### `{}`\n", group.name));
+        output.push('\n');
+        for field in group
+            .fields
+            .iter()
+            .filter_map(|entry| {
+                if let OptionEntry::Field(field) = entry {
+                    Some(field)
+                } else {
+                    None
+                }
+            })
+            .sorted_by_key(|field| field.name)
+        {
+            emit_field(&mut output, field, Some(group.name));
+            output.push_str("---\n\n");
+        }
+    }
+
+    if cli.dry_run {
+        print!("{output}");
+    } else {
+        // Read the existing file.
+        let file = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
+            .parent()
+            .expect("Failed to find root directory")
+            .join("README.md");
+        let existing = fs::read_to_string(&file)?;
+
+        // Extract the prefix.
+        let index = existing
+            .find(BEGIN_PRAGMA)
+            .expect("Unable to find begin pragma");
+        let prefix = &existing[..index + BEGIN_PRAGMA.len()];
+
+        // Extract the suffix.
+        let index = existing
+            .find(END_PRAGMA)
+            .expect("Unable to find end pragma");
+        let suffix = &existing[index..];
+
+        // Write the prefix, new contents, and suffix.
+        let mut f = OpenOptions::new().write(true).truncate(true).open(&file)?;
+        write!(f, "{prefix}\n\n")?;
+        write!(f, "{output}")?;
+        write!(f, "{suffix}")?;
+    }
+
+    Ok(())
+}

ruff_dev/src/generate_rules_table.rs

@@ -7,11 +7,15 @@ use std::path::PathBuf;
 
 use anyhow::Result;
 use clap::Args;
+use itertools::Itertools;
 use ruff::checks::{CheckCategory, CheckCode};
 use strum::IntoEnumIterator;
 
-const BEGIN_PRAGMA: &str = "<!-- Begin auto-generated sections. -->";
-const END_PRAGMA: &str = "<!-- End auto-generated sections. -->";
+const TABLE_BEGIN_PRAGMA: &str = "<!-- Begin auto-generated sections. -->";
+const TABLE_END_PRAGMA: &str = "<!-- End auto-generated sections. -->";
+
+const TOC_BEGIN_PRAGMA: &str = "<!-- Begin auto-generated table of contents. -->";
+const TOC_END_PRAGMA: &str = "<!-- End auto-generated table of contents. -->";
 
 #[derive(Args)]
 pub struct Cli {
@@ -22,73 +26,91 @@ pub struct Cli {
 
 pub fn main(cli: &Cli) -> Result<()> {
     // Generate the table string.
-    let mut output = String::new();
+    let mut table_out = String::new();
+    let mut toc_out = String::new();
     for check_category in CheckCategory::iter() {
-        output.push_str(&format!("### {}", check_category.title()));
-        output.push('\n');
-        output.push('\n');
+        let codes_csv: String = check_category.codes().iter().map(AsRef::as_ref).join(", ");
+        table_out.push_str(&format!("### {} ({codes_csv})", check_category.title()));
+        table_out.push('\n');
+        table_out.push('\n');
+
+        toc_out.push_str(&format!(
+            "   1. [{} ({})](#{}-{})\n",
+            check_category.title(),
+            codes_csv,
+            check_category.title().to_lowercase().replace(' ', "-"),
+            codes_csv.to_lowercase().replace(',', "-").replace(' ', "")
+        ));
 
         if let Some((url, platform)) = check_category.url() {
-            output.push_str(&format!(
+            table_out.push_str(&format!(
                 "For more, see [{}]({}) on {}.",
                 check_category.title(),
                 url,
                 platform
             ));
-            output.push('\n');
-            output.push('\n');
+            table_out.push('\n');
+            table_out.push('\n');
         }
 
-        output.push_str("| Code | Name | Message | Fix |");
-        output.push('\n');
-        output.push_str("| ---- | ---- | ------- | --- |");
-        output.push('\n');
+        table_out.push_str("| Code | Name | Message | Fix |");
+        table_out.push('\n');
+        table_out.push_str("| ---- | ---- | ------- | --- |");
+        table_out.push('\n');
 
         for check_code in CheckCode::iter() {
             if check_code.category() == check_category {
                 let check_kind = check_code.kind();
                 let fix_token = if check_kind.fixable() { "🛠" } else { "" };
-                output.push_str(&format!(
+                table_out.push_str(&format!(
                     "| {} | {} | {} | {} |",
                     check_kind.code().as_ref(),
                     check_kind.as_ref(),
                     check_kind.summary().replace('|', r"\|"),
                     fix_token
                 ));
-                output.push('\n');
+                table_out.push('\n');
             }
         }
-        output.push('\n');
+        table_out.push('\n');
     }
 
     if cli.dry_run {
-        print!("{output}");
+        print!("Table of Contents: {toc_out}\n Rules Tables: {table_out}");
     } else {
-        // Read the existing file.
-        let file = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
-            .parent()
-            .expect("Failed to find root directory")
-            .join("README.md");
-        let existing = fs::read_to_string(&file)?;
-
-        // Extract the prefix.
-        let index = existing
-            .find(BEGIN_PRAGMA)
-            .expect("Unable to find begin pragma");
-        let prefix = &existing[..index + BEGIN_PRAGMA.len()];
-
-        // Extract the suffix.
-        let index = existing
-            .find(END_PRAGMA)
-            .expect("Unable to find end pragma");
-        let suffix = &existing[index..];
-
-        // Write the prefix, new contents, and suffix.
-        let mut f = OpenOptions::new().write(true).truncate(true).open(&file)?;
-        write!(f, "{prefix}\n\n")?;
-        write!(f, "{output}")?;
-        write!(f, "{suffix}")?;
+        // Extra newline in the markdown numbered list looks weird
+        replace_readme_section(toc_out.trim_end(), TOC_BEGIN_PRAGMA, TOC_END_PRAGMA)?;
+        replace_readme_section(&table_out, TABLE_BEGIN_PRAGMA, TABLE_END_PRAGMA)?;
     }
 
     Ok(())
 }
+
+fn replace_readme_section(content: &str, begin_pragma: &str, end_pragma: &str) -> Result<()> {
+    // Read the existing file.
+    let file = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
+        .parent()
+        .expect("Failed to find root directory")
+        .join("README.md");
+    let existing = fs::read_to_string(&file)?;
+
+    // Extract the prefix.
+    let index = existing
+        .find(begin_pragma)
+        .expect("Unable to find begin pragma");
+    let prefix = &existing[..index + begin_pragma.len()];
+
+    // Extract the suffix.
+    let index = existing
+        .find(end_pragma)
+        .expect("Unable to find end pragma");
+    let suffix = &existing[index..];
+
+    // Write the prefix, new contents, and suffix.
+    let mut f = OpenOptions::new().write(true).truncate(true).open(&file)?;
+    writeln!(f, "{prefix}")?;
+    write!(f, "{content}")?;
+    write!(f, "{suffix}")?;
+
+    Ok(())
+}

ruff_dev/src/lib.rs

@@ -12,6 +12,7 @@
 )]
 
 pub mod generate_check_code_prefix;
+pub mod generate_options;
 pub mod generate_rules_table;
 pub mod generate_source_code;
 pub mod print_ast;

ruff_dev/src/main.rs

@@ -14,8 +14,8 @@
 use anyhow::Result;
 use clap::{Parser, Subcommand};
 use ruff_dev::{
-    generate_check_code_prefix, generate_rules_table, generate_source_code, print_ast, print_cst,
-    print_tokens,
+    generate_check_code_prefix, generate_options, generate_rules_table, generate_source_code,
+    print_ast, print_cst, print_tokens,
 };
 
 #[derive(Parser)]
@@ -32,6 +32,8 @@ enum Commands {
     GenerateCheckCodePrefix(generate_check_code_prefix::Cli),
     /// Generate a Markdown-compatible table of supported lint rules.
     GenerateRulesTable(generate_rules_table::Cli),
+    /// Generate a Markdown-compatible listing of configuration options.
+    GenerateOptions(generate_options::Cli),
     /// Run round-trip source code generation on a given Python file.
     GenerateSourceCode(generate_source_code::Cli),
     /// Print the AST for a given Python file.
@@ -48,6 +50,7 @@ fn main() -> Result<()> {
         Commands::GenerateCheckCodePrefix(args) => generate_check_code_prefix::main(args)?,
         Commands::GenerateRulesTable(args) => generate_rules_table::main(args)?,
         Commands::GenerateSourceCode(args) => generate_source_code::main(args)?,
+        Commands::GenerateOptions(args) => generate_options::main(args)?,
         Commands::PrintAST(args) => print_ast::main(args)?,
         Commands::PrintCST(args) => print_cst::main(args)?,
         Commands::PrintTokens(args) => print_tokens::main(args)?,

ruff_macros/Cargo.toml

@@ -0,0 +1,13 @@
+[package]
+name = "ruff_macros"
+version = "0.0.176"
+edition = "2021"
+
+[lib]
+proc-macro = true
+
+[dependencies]
+proc-macro2 = { version = "1.0.47" }
+quote = { version = "1.0.21" }
+syn = { version = "1.0.103", features = ["derive", "parsing"] }
+textwrap = { version = "0.16.0" }

ruff_macros/src/lib.rs

@@ -0,0 +1,177 @@
+#![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 quote::{quote, quote_spanned};
+use syn::parse::{Parse, ParseStream};
+use syn::token::Comma;
+use syn::{
+    parse_macro_input, AngleBracketedGenericArguments, Attribute, Data, DataStruct, DeriveInput,
+    Field, Fields, Lit, LitStr, Path, PathArguments, PathSegment, Token, Type, TypePath,
+};
+
+#[proc_macro_derive(ConfigurationOptions, attributes(option, option_group))]
+pub fn derive(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
+    let input = parse_macro_input!(input as DeriveInput);
+
+    derive_impl(input)
+        .unwrap_or_else(syn::Error::into_compile_error)
+        .into()
+}
+
+fn derive_impl(input: DeriveInput) -> syn::Result<proc_macro2::TokenStream> {
+    let DeriveInput { ident, data, .. } = input;
+
+    match data {
+        Data::Struct(DataStruct {
+            fields: Fields::Named(fields),
+            ..
+        }) => {
+            let mut output = vec![];
+
+            for field in fields.named.iter() {
+                if let Some(attr) = field.attrs.iter().find(|a| a.path.is_ident("option")) {
+                    output.push(handle_option(field, attr)?);
+                };
+
+                if field.attrs.iter().any(|a| a.path.is_ident("option_group")) {
+                    output.push(handle_option_group(field)?);
+                };
+            }
+
+            Ok(quote! {
+              use crate::settings::options_base::{OptionEntry, OptionField, OptionGroup, ConfigurationOptions};
+
+              #[automatically_derived]
+              impl ConfigurationOptions for #ident {
+                  fn get_available_options() -> Vec<OptionEntry> {
+                      vec![#(#output),*]
+                  }
+              }
+            })
+        }
+        _ => Err(syn::Error::new(
+            ident.span(),
+            "Can only derive ConfigurationOptions from structs with named fields.",
+        )),
+    }
+}
+
+/// For a field with type `Option<Foobar>` where `Foobar` itself is a struct
+/// deriving `ConfigurationOptions`, create code that calls retrieves options
+/// from that group: `Foobar::get_available_options()`
+fn handle_option_group(field: &Field) -> syn::Result<proc_macro2::TokenStream> {
+    // unwrap is safe because we're only going over named fields
+    let ident = field.ident.as_ref().unwrap();
+
+    match &field.ty {
+        Type::Path(TypePath {
+            path: Path { segments, .. },
+            ..
+        }) => match segments.first() {
+            Some(PathSegment {
+                ident: type_ident,
+                arguments:
+                    PathArguments::AngleBracketed(AngleBracketedGenericArguments { args, .. }),
+                ..
+            }) if type_ident == "Option" => {
+                let path = &args[0];
+                let kebab_name = LitStr::new(&ident.to_string().replace('_', "-"), ident.span());
+
+                Ok(quote_spanned!(
+                    ident.span() => OptionEntry::Group(OptionGroup {
+                        name: #kebab_name,
+                        fields: #path::get_available_options(),
+                    })
+                ))
+            }
+            _ => Err(syn::Error::new(
+                ident.span(),
+                "Expected `Option<_>`  as type.",
+            )),
+        },
+        _ => Err(syn::Error::new(ident.span(), "Expected type.")),
+    }
+}
+
+/// Parse an `#[option(doc="...", default="...", value_type="...",
+/// example="...")]` attribute and return data in the form of an `OptionField`.
+fn handle_option(field: &Field, attr: &Attribute) -> syn::Result<proc_macro2::TokenStream> {
+    // unwrap is safe because we're only going over named fields
+    let ident = field.ident.as_ref().unwrap();
+
+    let FieldAttributes {
+        doc,
+        default,
+        value_type,
+        example,
+    } = attr.parse_args::<FieldAttributes>()?;
+    let kebab_name = LitStr::new(&ident.to_string().replace('_', "-"), ident.span());
+
+    Ok(quote_spanned!(
+        ident.span() => OptionEntry::Field(OptionField {
+            name: #kebab_name,
+            doc: &#doc,
+            default: &#default,
+            value_type: &#value_type,
+            example: &#example,
+        })
+    ))
+}
+
+#[derive(Debug)]
+struct FieldAttributes {
+    doc: String,
+    default: String,
+    value_type: String,
+    example: String,
+}
+
+impl Parse for FieldAttributes {
+    fn parse(input: ParseStream) -> syn::Result<Self> {
+        let doc = _parse_key_value(input, "doc")?;
+        input.parse::<Comma>()?;
+        let default = _parse_key_value(input, "default")?;
+        input.parse::<Comma>()?;
+        let value_type = _parse_key_value(input, "value_type")?;
+        input.parse::<Comma>()?;
+        let example = _parse_key_value(input, "example")?;
+        if !input.is_empty() {
+            input.parse::<Comma>()?;
+        }
+
+        Ok(FieldAttributes {
+            doc: textwrap::dedent(&doc).trim_matches('\n').to_string(),
+            default,
+            value_type,
+            example: textwrap::dedent(&example).trim_matches('\n').to_string(),
+        })
+    }
+}
+
+fn _parse_key_value(input: ParseStream, name: &str) -> syn::Result<String> {
+    let ident: proc_macro2::Ident = input.parse()?;
+    if ident != name {
+        return Err(syn::Error::new(
+            ident.span(),
+            format!("Expected `{name}` name"),
+        ));
+    }
+
+    input.parse::<Token![=]>()?;
+    let value: Lit = input.parse()?;
+
+    match &value {
+        Lit::Str(v) => Ok(v.value()),
+        _ => Err(syn::Error::new(value.span(), "Expected literal string")),
+    }
+}

src/ast/branch_detection.rs

@@ -0,0 +1,105 @@
+use std::cmp::Ordering;
+
+use rustc_hash::FxHashMap;
+use rustpython_ast::ExcepthandlerKind::ExceptHandler;
+use rustpython_ast::Stmt;
+use rustpython_parser::ast::StmtKind;
+
+use crate::ast::types::RefEquality;
+
+/// Return the common ancestor of `left` and `right` below `stop`, or `None`.
+fn common_ancestor<'a>(
+    left: &'a RefEquality<'a, Stmt>,
+    right: &'a RefEquality<'a, Stmt>,
+    stop: Option<&'a RefEquality<'a, Stmt>>,
+    depths: &'a FxHashMap<RefEquality<'a, Stmt>, usize>,
+    child_to_parent: &'a FxHashMap<RefEquality<'a, Stmt>, RefEquality<'a, Stmt>>,
+) -> Option<&'a RefEquality<'a, Stmt>> {
+    if let Some(stop) = stop {
+        if left == stop || right == stop {
+            return None;
+        }
+    }
+    if left == right {
+        return Some(left);
+    }
+
+    let left_depth = depths.get(left)?;
+    let right_depth = depths.get(right)?;
+    match left_depth.cmp(right_depth) {
+        Ordering::Less => common_ancestor(
+            left,
+            child_to_parent.get(right)?,
+            stop,
+            depths,
+            child_to_parent,
+        ),
+        Ordering::Equal => common_ancestor(
+            child_to_parent.get(left)?,
+            child_to_parent.get(right)?,
+            stop,
+            depths,
+            child_to_parent,
+        ),
+        Ordering::Greater => common_ancestor(
+            child_to_parent.get(left)?,
+            right,
+            stop,
+            depths,
+            child_to_parent,
+        ),
+    }
+}
+
+/// Return the alternative branches for a given node.
+fn alternatives<'a>(node: &'a RefEquality<'a, Stmt>) -> Vec<Vec<RefEquality<'a, Stmt>>> {
+    match &node.0.node {
+        StmtKind::If { body, .. } => vec![body.iter().map(RefEquality).collect()],
+        StmtKind::Try {
+            body,
+            handlers,
+            orelse,
+            ..
+        } => vec![body.iter().chain(orelse.iter()).map(RefEquality).collect()]
+            .into_iter()
+            .chain(handlers.iter().map(|handler| {
+                let ExceptHandler { body, .. } = &handler.node;
+                body.iter().map(RefEquality).collect()
+            }))
+            .collect(),
+        _ => vec![],
+    }
+}
+
+/// Return `true` if `node` is a descendent of any of the nodes in `ancestors`.
+fn descendant_of<'a>(
+    node: &RefEquality<'a, Stmt>,
+    ancestors: &[RefEquality<'a, Stmt>],
+    stop: &RefEquality<'a, Stmt>,
+    depths: &FxHashMap<RefEquality<'a, Stmt>, usize>,
+    child_to_parent: &FxHashMap<RefEquality<'a, Stmt>, RefEquality<'a, Stmt>>,
+) -> bool {
+    ancestors.iter().any(|ancestor| {
+        common_ancestor(node, ancestor, Some(stop), depths, child_to_parent).is_some()
+    })
+}
+
+/// Return `true` if `left` and `right` are on different branches of an `if` or
+/// `try` statement.
+pub fn different_forks<'a>(
+    left: &RefEquality<'a, Stmt>,
+    right: &RefEquality<'a, Stmt>,
+    depths: &FxHashMap<RefEquality<'a, Stmt>, usize>,
+    child_to_parent: &FxHashMap<RefEquality<'a, Stmt>, RefEquality<'a, Stmt>>,
+) -> bool {
+    if let Some(ancestor) = common_ancestor(left, right, None, depths, child_to_parent) {
+        for items in alternatives(ancestor) {
+            let l = descendant_of(left, &items, ancestor, depths, child_to_parent);
+            let r = descendant_of(right, &items, ancestor, depths, child_to_parent);
+            if l ^ r {
+                return true;
+            }
+        }
+    }
+    false
+}

src/ast/cast.rs

@@ -0,0 +1,9 @@
+use rustpython_ast::{Expr, Stmt, StmtKind};
+
+pub fn decorator_list(stmt: &Stmt) -> &Vec<Expr> {
+    match &stmt.node {
+        StmtKind::FunctionDef { decorator_list, .. }
+        | StmtKind::AsyncFunctionDef { decorator_list, .. } => decorator_list,
+        _ => panic!("Expected StmtKind::FunctionDef | StmtKind::AsyncFunctionDef"),
+    }
+}

src/ast/function_type.rs

@@ -0,0 +1,65 @@
+use rustc_hash::{FxHashMap, FxHashSet};
+use rustpython_ast::Expr;
+
+use crate::ast::helpers::{
+    collect_call_paths, dealias_call_path, match_call_path, to_module_and_member,
+};
+use crate::ast::types::{Scope, ScopeKind};
+
+const CLASS_METHODS: [&str; 3] = ["__new__", "__init_subclass__", "__class_getitem__"];
+const METACLASS_BASES: [(&str, &str); 2] = [("", "type"), ("abc", "ABCMeta")];
+
+pub enum FunctionType {
+    Function,
+    Method,
+    ClassMethod,
+    StaticMethod,
+}
+
+/// Classify a function based on its scope, name, and decorators.
+pub fn classify(
+    scope: &Scope,
+    name: &str,
+    decorator_list: &[Expr],
+    from_imports: &FxHashMap<&str, FxHashSet<&str>>,
+    import_aliases: &FxHashMap<&str, &str>,
+    classmethod_decorators: &[String],
+    staticmethod_decorators: &[String],
+) -> FunctionType {
+    let ScopeKind::Class(scope) = &scope.kind else {
+        return FunctionType::Function;
+    };
+    // Special-case class method, like `__new__`.
+    if CLASS_METHODS.contains(&name)
+        || scope.bases.iter().any(|expr| {
+            // The class itself extends a known metaclass, so all methods are class methods.
+            let call_path = dealias_call_path(collect_call_paths(expr), import_aliases);
+            METACLASS_BASES
+                .iter()
+                .any(|(module, member)| match_call_path(&call_path, module, member, from_imports))
+        })
+        || decorator_list.iter().any(|expr| {
+            // The method is decorated with a class method decorator (like `@classmethod`).
+            let call_path = dealias_call_path(collect_call_paths(expr), import_aliases);
+            classmethod_decorators.iter().any(|decorator| {
+                let (module, member) = to_module_and_member(decorator);
+                match_call_path(&call_path, module, member, from_imports)
+            })
+        })
+    {
+        FunctionType::ClassMethod
+    } else if decorator_list.iter().any(|expr| {
+        // The method is decorated with a static method decorator (like
+        // `@staticmethod`).
+        let call_path = dealias_call_path(collect_call_paths(expr), import_aliases);
+        staticmethod_decorators.iter().any(|decorator| {
+            let (module, member) = to_module_and_member(decorator);
+            match_call_path(&call_path, module, member, from_imports)
+        })
+    }) {
+        FunctionType::StaticMethod
+    } else {
+        // It's an instance method.
+        FunctionType::Method
+    }
+}

src/ast/mod.rs

@@ -1,3 +1,6 @@
+pub mod branch_detection;
+pub mod cast;
+pub mod function_type;
 pub mod helpers;
 pub mod operations;
 pub mod relocate;

src/ast/operations.rs

@@ -1,12 +1,15 @@
+use rustc_hash::FxHashMap;
 use rustpython_ast::{Cmpop, Located};
 use rustpython_parser::ast::{Constant, Expr, ExprKind, Stmt, StmtKind};
 use rustpython_parser::lexer;
 use rustpython_parser::lexer::Tok;
 
-use crate::ast::types::{BindingKind, Scope};
+use crate::ast::types::{Binding, BindingKind, Scope};
+use crate::ast::visitor;
+use crate::ast::visitor::Visitor;
 
 /// Extract the names bound to a given __all__ assignment.
-pub fn extract_all_names(stmt: &Stmt, scope: &Scope) -> Vec<String> {
+pub fn extract_all_names(stmt: &Stmt, scope: &Scope, bindings: &[Binding]) -> Vec<String> {
     fn add_to_names(names: &mut Vec<String>, elts: &[Expr]) {
         for elt in elts {
             if let ExprKind::Constant {
@@ -23,8 +26,8 @@ pub fn extract_all_names(stmt: &Stmt, scope: &Scope) -> Vec<String> {
 
     // Grab the existing bound __all__ values.
     if let StmtKind::AugAssign { .. } = &stmt.node {
-        if let Some(binding) = scope.values.get("__all__") {
-            if let BindingKind::Export(existing) = &binding.kind {
+        if let Some(index) = scope.values.get("__all__") {
+            if let BindingKind::Export(existing) = &bindings[*index].kind {
                 names.extend_from_slice(existing);
             }
         }
@@ -69,6 +72,38 @@ pub fn extract_all_names(stmt: &Stmt, scope: &Scope) -> Vec<String> {
     names
 }
 
+#[derive(Default)]
+struct GlobalVisitor<'a> {
+    globals: FxHashMap<&'a str, &'a Stmt>,
+}
+
+impl<'a> Visitor<'a> for GlobalVisitor<'a> {
+    fn visit_stmt(&mut self, stmt: &'a Stmt) {
+        match &stmt.node {
+            StmtKind::Global { names } => {
+                for name in names {
+                    self.globals.insert(name, stmt);
+                }
+            }
+            StmtKind::FunctionDef { .. }
+            | StmtKind::AsyncFunctionDef { .. }
+            | StmtKind::ClassDef { .. } => {
+                // Don't recurse.
+            }
+            _ => visitor::walk_stmt(self, stmt),
+        }
+    }
+}
+
+/// Extract a map from global name to its last-defining `Stmt`.
+pub fn extract_globals(body: &[Stmt]) -> FxHashMap<&str, &Stmt> {
+    let mut visitor = GlobalVisitor::default();
+    for stmt in body {
+        visitor.visit_stmt(stmt);
+    }
+    visitor.globals
+}
+
 /// Check if a node is parent of a conditional branch.
 pub fn on_conditional_branch<'a>(parents: &mut impl Iterator<Item = &'a Stmt>) -> bool {
     parents.any(|parent| {
@@ -94,23 +129,132 @@ pub fn in_nested_block<'a>(parents: &mut impl Iterator<Item = &'a Stmt>) -> bool
     })
 }
 
-/// Check if a node represents an unpacking assignment.
-pub fn is_unpacking_assignment(stmt: &Stmt) -> bool {
-    let StmtKind::Assign { targets, value, .. } = &stmt.node else {
-        return false;
-    };
-    if !targets.iter().any(|child| {
-        matches!(
-            child.node,
-            ExprKind::Set { .. } | ExprKind::List { .. } | ExprKind::Tuple { .. }
-        )
-    }) {
-        return false;
+/// Returns `true` if `parent` contains `child`.
+fn contains(parent: &Expr, child: &Expr) -> bool {
+    match &parent.node {
+        ExprKind::BoolOp { values, .. } => values.iter().any(|parent| contains(parent, child)),
+        ExprKind::NamedExpr { target, value } => contains(target, child) || contains(value, child),
+        ExprKind::BinOp { left, right, .. } => contains(left, child) || contains(right, child),
+        ExprKind::UnaryOp { operand, .. } => contains(operand, child),
+        ExprKind::Lambda { body, .. } => contains(body, child),
+        ExprKind::IfExp { test, body, orelse } => {
+            contains(test, child) || contains(body, child) || contains(orelse, child)
+        }
+        ExprKind::Dict { keys, values } => keys
+            .iter()
+            .chain(values.iter())
+            .any(|parent| contains(parent, child)),
+        ExprKind::Set { elts } => elts.iter().any(|parent| contains(parent, child)),
+        ExprKind::ListComp { elt, .. } => contains(elt, child),
+        ExprKind::SetComp { elt, .. } => contains(elt, child),
+        ExprKind::DictComp { key, value, .. } => contains(key, child) || contains(value, child),
+        ExprKind::GeneratorExp { elt, .. } => contains(elt, child),
+        ExprKind::Await { value } => contains(value, child),
+        ExprKind::Yield { value } => value.as_ref().map_or(false, |value| contains(value, child)),
+        ExprKind::YieldFrom { value } => contains(value, child),
+        ExprKind::Compare {
+            left, comparators, ..
+        } => contains(left, child) || comparators.iter().any(|parent| contains(parent, child)),
+        ExprKind::Call {
+            func,
+            args,
+            keywords,
+        } => {
+            contains(func, child)
+                || args.iter().any(|parent| contains(parent, child))
+                || keywords
+                    .iter()
+                    .any(|keyword| contains(&keyword.node.value, child))
+        }
+        ExprKind::FormattedValue {
+            value, format_spec, ..
+        } => {
+            contains(value, child)
+                || format_spec
+                    .as_ref()
+                    .map_or(false, |value| contains(value, child))
+        }
+        ExprKind::JoinedStr { values } => values.iter().any(|parent| contains(parent, child)),
+        ExprKind::Constant { .. } => false,
+        ExprKind::Attribute { value, .. } => contains(value, child),
+        ExprKind::Subscript { value, slice, .. } => {
+            contains(value, child) || contains(slice, child)
+        }
+        ExprKind::Starred { value, .. } => contains(value, child),
+        ExprKind::Name { .. } => parent == child,
+        ExprKind::List { elts, .. } => elts.iter().any(|parent| contains(parent, child)),
+        ExprKind::Tuple { elts, .. } => elts.iter().any(|parent| contains(parent, child)),
+        ExprKind::Slice { lower, upper, step } => {
+            lower.as_ref().map_or(false, |value| contains(value, child))
+                || upper.as_ref().map_or(false, |value| contains(value, child))
+                || step.as_ref().map_or(false, |value| contains(value, child))
+        }
+    }
+}
+
+/// Check if a node represents an unpacking assignment.
+pub fn is_unpacking_assignment(parent: &Stmt, child: &Expr) -> bool {
+    match &parent.node {
+        StmtKind::With { items, .. } => items.iter().any(|item| {
+            if let Some(optional_vars) = &item.optional_vars {
+                if matches!(optional_vars.node, ExprKind::Tuple { .. }) {
+                    if contains(optional_vars, child) {
+                        return true;
+                    }
+                }
+            }
+            false
+        }),
+        StmtKind::Assign { targets, value, .. } => {
+            // In `(a, b) = (1, 2)`, `(1, 2)` is the target, and it is a tuple.
+            let value_is_tuple = matches!(
+                &value.node,
+                ExprKind::Set { .. } | ExprKind::List { .. } | ExprKind::Tuple { .. }
+            );
+            // In `(a, b) = coords = (1, 2)`, `(a, b)` and `coords` are the targets, and
+            // `(a, b`) is a tuple. (We use "tuple" as a placeholder for any
+            // unpackable expression.)
+            let targets_are_tuples = targets.iter().all(|item| {
+                matches!(
+                    item.node,
+                    ExprKind::Set { .. } | ExprKind::List { .. } | ExprKind::Tuple { .. }
+                )
+            });
+            // If we're looking at `a` in `(a, b) = coords = (1, 2)`, then we should
+            // identify that the current expression is in a tuple.
+            let child_in_tuple = targets_are_tuples
+                || targets.iter().any(|item| {
+                    matches!(
+                        item.node,
+                        ExprKind::Set { .. } | ExprKind::List { .. } | ExprKind::Tuple { .. }
+                    ) && contains(item, child)
+                });
+
+            // If our child is a tuple, and value is not, it's always an unpacking
+            // expression. Ex) `x, y = tup`
+            if child_in_tuple && !value_is_tuple {
+                return true;
+            }
+
+            // If our child isn't a tuple, but value is, it's never an unpacking expression.
+            // Ex) `coords = (1, 2)`
+            if !child_in_tuple && value_is_tuple {
+                return false;
+            }
+
+            // If our target and the value are both tuples, then it's an unpacking
+            // expression assuming there's at least one non-tuple child.
+            // Ex) Given `(x, y) = coords = 1, 2`, `(x, y)` is considered an unpacking
+            // expression. Ex) Given `(x, y) = (a, b) = 1, 2`, `(x, y)` isn't
+            // considered an unpacking expression.
+            if child_in_tuple && value_is_tuple {
+                return !targets_are_tuples;
+            }
+
+            false
+        }
+        _ => false,
     }
-    !matches!(
-        &value.node,
-        ExprKind::Set { .. } | ExprKind::List { .. } | ExprKind::Tuple { .. }
-    )
 }
 
 pub type LocatedCmpop<U = ()> = Located<Cmpop, U>;

src/ast/types.rs

@@ -1,7 +1,7 @@
 use std::sync::atomic::{AtomicUsize, Ordering};
 
 use rustc_hash::FxHashMap;
-use rustpython_ast::{Expr, Keyword, Stmt};
+use rustpython_ast::{Arguments, Expr, Keyword, Stmt};
 use rustpython_parser::ast::{Located, Location};
 
 fn id() -> usize {
@@ -30,36 +30,60 @@ impl Range {
     }
 }
 
-#[derive(Clone, Debug)]
-pub struct FunctionScope {
+#[derive(Debug)]
+pub struct FunctionDef<'a> {
+    // Properties derived from StmtKind::FunctionDef.
+    pub name: &'a str,
+    pub args: &'a Arguments,
+    pub body: &'a [Stmt],
+    pub decorator_list: &'a [Expr],
+    // pub returns: Option<&'a Expr>,
+    // pub type_comment: Option<&'a str>,
+    // Scope-specific properties.
+    // TODO(charlie): Create AsyncFunctionDef to mirror the AST.
     pub async_: bool,
-    pub uses_locals: bool,
+    pub globals: FxHashMap<&'a str, &'a Stmt>,
 }
 
-#[derive(Clone, Debug)]
-pub struct ClassScope<'a> {
+#[derive(Debug)]
+pub struct ClassDef<'a> {
+    // Properties derived from StmtKind::ClassDef.
     pub name: &'a str,
     pub bases: &'a [Expr],
     pub keywords: &'a [Keyword],
+    // pub body: &'a [Stmt],
     pub decorator_list: &'a [Expr],
+    // Scope-specific properties.
+    pub globals: FxHashMap<&'a str, &'a Stmt>,
 }
 
-#[derive(Clone, Debug)]
+#[derive(Debug)]
+pub struct Lambda<'a> {
+    pub args: &'a Arguments,
+    pub body: &'a Expr,
+}
+
+#[derive(Debug)]
 pub enum ScopeKind<'a> {
-    Class(ClassScope<'a>),
-    Function(FunctionScope),
+    Class(ClassDef<'a>),
+    Function(FunctionDef<'a>),
     Generator,
     Module,
     Arg,
-    Lambda,
+    Lambda(Lambda<'a>),
 }
 
-#[derive(Clone, Debug)]
+#[derive(Debug)]
 pub struct Scope<'a> {
     pub id: usize,
     pub kind: ScopeKind<'a>,
     pub import_starred: bool,
-    pub values: FxHashMap<&'a str, Binding>,
+    pub uses_locals: bool,
+    /// A map from bound name to binding index.
+    pub values: FxHashMap<&'a str, usize>,
+    /// A list of (name, index) pairs for bindings that were overridden in the
+    /// scope.
+    pub overridden: Vec<(&'a str, usize)>,
 }
 
 impl<'a> Scope<'a> {
@@ -68,43 +92,122 @@ impl<'a> Scope<'a> {
             id: id(),
             kind,
             import_starred: false,
+            uses_locals: false,
             values: FxHashMap::default(),
+            overridden: Vec::new(),
         }
     }
 }
 
-#[derive(Clone, Debug)]
-pub struct BindingContext {
-    pub defined_by: usize,
-    pub defined_in: Option<usize>,
-}
-
 #[derive(Clone, Debug)]
 pub enum BindingKind {
     Annotation,
     Argument,
     Assignment,
-    // TODO(charlie): This seems to be a catch-all.
     Binding,
     LoopVar,
     Global,
     Nonlocal,
     Builtin,
     ClassDefinition,
-    Definition,
+    FunctionDefinition,
     Export(Vec<String>),
     FutureImportation,
     StarImportation(Option<usize>, Option<String>),
-    Importation(String, String, BindingContext),
-    FromImportation(String, String, BindingContext),
-    SubmoduleImportation(String, String, BindingContext),
+    Importation(String, String),
+    FromImportation(String, String),
+    SubmoduleImportation(String, String),
 }
 
 #[derive(Clone, Debug)]
-pub struct Binding {
+pub struct Binding<'a> {
     pub kind: BindingKind,
     pub range: Range,
+    /// The statement in which the `Binding` was defined.
+    pub source: Option<RefEquality<'a, Stmt>>,
     /// Tuple of (scope index, range) indicating the scope and range at which
     /// the binding was last used.
     pub used: Option<(usize, Range)>,
 }
+
+// Pyflakes defines the following binding hierarchy (via inheritance):
+//   Binding
+//    ExportBinding
+//    Annotation
+//    Argument
+//    Assignment
+//      NamedExprAssignment
+//    Definition
+//      FunctionDefinition
+//      ClassDefinition
+//      Builtin
+//      Importation
+//        SubmoduleImportation
+//        ImportationFrom
+//        StarImportation
+//        FutureImportation
+
+impl<'a> Binding<'a> {
+    pub fn is_definition(&self) -> bool {
+        matches!(
+            self.kind,
+            BindingKind::ClassDefinition
+                | BindingKind::FunctionDefinition
+                | BindingKind::Builtin
+                | BindingKind::FutureImportation
+                | BindingKind::StarImportation(..)
+                | BindingKind::Importation(..)
+                | BindingKind::FromImportation(..)
+                | BindingKind::SubmoduleImportation(..)
+        )
+    }
+
+    pub fn redefines(&self, existing: &'a Binding) -> bool {
+        match &self.kind {
+            BindingKind::Importation(_, full_name) | BindingKind::FromImportation(_, full_name) => {
+                if let BindingKind::SubmoduleImportation(_, existing_full_name) = &existing.kind {
+                    return full_name == existing_full_name;
+                }
+            }
+            BindingKind::SubmoduleImportation(_, full_name) => {
+                if let BindingKind::Importation(_, existing_full_name)
+                | BindingKind::FromImportation(_, existing_full_name)
+                | BindingKind::SubmoduleImportation(_, existing_full_name) = &existing.kind
+                {
+                    return full_name == existing_full_name;
+                }
+            }
+            BindingKind::Annotation => {
+                return false;
+            }
+            BindingKind::FutureImportation => {
+                return false;
+            }
+            BindingKind::StarImportation(..) => {
+                return false;
+            }
+            _ => {}
+        }
+        existing.is_definition()
+    }
+}
+
+#[derive(Debug, Copy, Clone)]
+pub struct RefEquality<'a, T>(pub &'a T);
+
+impl<'a, T> std::hash::Hash for RefEquality<'a, T> {
+    fn hash<H>(&self, state: &mut H)
+    where
+        H: std::hash::Hasher,
+    {
+        (self.0 as *const T).hash(state);
+    }
+}
+
+impl<'a, 'b, T> PartialEq<RefEquality<'b, T>> for RefEquality<'a, T> {
+    fn eq(&self, other: &RefEquality<'b, T>) -> bool {
+        std::ptr::eq(self.0, other.0)
+    }
+}
+
+impl<'a, T> Eq for RefEquality<'a, T> {}

src/ast/visitor.rs

@@ -159,8 +159,8 @@ pub fn walk_stmt<'a, V: Visitor<'a> + ?Sized>(visitor: &mut V, stmt: &'a Stmt) {
             orelse,
             ..
         } => {
-            visitor.visit_expr(target);
             visitor.visit_expr(iter);
+            visitor.visit_expr(target);
             for stmt in body {
                 visitor.visit_stmt(stmt);
             }
@@ -175,8 +175,8 @@ pub fn walk_stmt<'a, V: Visitor<'a> + ?Sized>(visitor: &mut V, stmt: &'a Stmt) {
             orelse,
             ..
         } => {
-            visitor.visit_expr(target);
             visitor.visit_expr(iter);
+            visitor.visit_expr(target);
             for stmt in body {
                 visitor.visit_stmt(stmt);
             }

src/ast/whitespace.rs

@@ -1,3 +1,4 @@
+use std::borrow::Cow;
 use std::str::Lines;
 
 use rustpython_ast::{Located, Location};
@@ -5,31 +6,26 @@ use rustpython_ast::{Located, Location};
 use crate::ast::types::Range;
 use crate::check_ast::Checker;
 
+/// Extract the leading indentation from a line.
+pub fn indentation<'a, T>(checker: &'a Checker, located: &'a Located<T>) -> Cow<'a, str> {
+    let range = Range::from_located(located);
+    checker.locator.slice_source_code_range(&Range {
+        location: Location::new(range.location.row(), 0),
+        end_location: Location::new(range.location.row(), range.location.column()),
+    })
+}
+
 /// Extract the leading words from a line of text.
-pub fn leading_words(line: &str) -> String {
-    line.trim()
-        .chars()
-        .take_while(|char| char.is_alphanumeric() || char.is_whitespace())
-        .collect()
+pub fn leading_words(line: &str) -> &str {
+    let line = line.trim();
+    line.find(|char: char| !char.is_alphanumeric() && !char.is_whitespace())
+        .map_or(line, |index| &line[..index])
 }
 
 /// Extract the leading whitespace from a line of text.
-pub fn leading_space(line: &str) -> String {
-    line.chars()
-        .take_while(|char| char.is_whitespace())
-        .collect()
-}
-
-/// Extract the leading indentation from a line.
-pub fn indentation<T>(checker: &Checker, located: &Located<T>) -> String {
-    let range = Range::from_located(located);
-    checker
-        .locator
-        .slice_source_code_range(&Range {
-            location: Location::new(range.location.row(), 0),
-            end_location: Location::new(range.location.row(), range.location.column()),
-        })
-        .to_string()
+pub fn leading_space(line: &str) -> &str {
+    line.find(|char: char| !char.is_whitespace())
+        .map_or(line, |index| &line[..index])
 }
 
 /// Replace any non-whitespace characters from an indentation string.

src/cache.rs

@@ -139,20 +139,21 @@ pub fn get(
         return None;
     };
 
-    if let Ok(encoded) = read_sync(cache_key(path, settings, autofix)) {
-        match bincode::deserialize::<CheckResult>(&encoded[..]) {
-            Ok(CheckResult {
-                metadata: CacheMetadata { mtime },
-                messages,
-            }) => {
-                if FileTime::from_last_modification_time(metadata).unix_seconds() == mtime {
-                    return Some(messages);
-                }
-            }
-            Err(e) => error!("Failed to deserialize encoded cache entry: {e:?}"),
+    let encoded = read_sync(cache_key(path, settings, autofix)).ok()?;
+    let (mtime, messages) = match bincode::deserialize::<CheckResult>(&encoded[..]) {
+        Ok(CheckResult {
+            metadata: CacheMetadata { mtime },
+            messages,
+        }) => (mtime, messages),
+        Err(e) => {
+            error!("Failed to deserialize encoded cache entry: {e:?}");
+            return None;
         }
+    };
+    if FileTime::from_last_modification_time(metadata).unix_seconds() != mtime {
+        return None;
     }
-    None
+    Some(messages)
 }
 
 /// Set a value in the cache.

src/check_imports.rs

@@ -1,5 +1,7 @@
 //! Lint rules based on import analysis.
 
+use std::path::Path;
+
 use rustpython_parser::ast::Suite;
 
 use crate::ast::visitor::Visitor;
@@ -33,8 +35,9 @@ pub fn check_imports(
     directives: &IsortDirectives,
     settings: &Settings,
     autofix: bool,
+    path: &Path,
 ) -> Vec<Check> {
-    let mut tracker = ImportTracker::new(directives);
+    let mut tracker = ImportTracker::new(directives, path);
     for stmt in python_ast {
         tracker.visit_stmt(stmt);
     }

src/check_lines.rs

@@ -7,7 +7,7 @@ use rustpython_parser::ast::Location;
 
 use crate::ast::types::Range;
 use crate::autofix::Fix;
-use crate::checks::{Check, CheckCode, CheckKind, REDIRECTS};
+use crate::checks::{Check, CheckCode, CheckKind, CODE_REDIRECTS};
 use crate::noqa;
 use crate::noqa::{is_file_exempt, Directive};
 use crate::settings::Settings;
@@ -20,19 +20,18 @@ static URL_REGEX: Lazy<Regex> = Lazy::new(|| Regex::new(r"^https?://\S+$").unwra
 
 /// 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 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
-        }
-    } else {
-        false
+    if length <= limit {
+        return false;
     }
+    let mut chunks = line.split_whitespace();
+    let (Some(first), Some(_)) = (chunks.next(), chunks.next()) else {
+        // Single word / no printable chars - no way to make the line shorter
+        return false;
+    };
+
+    // 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)))
 }
 
 pub fn check_lines(
@@ -210,7 +209,7 @@ pub fn check_lines(
                     let mut invalid_codes = vec![];
                     let mut valid_codes = vec![];
                     for code in codes {
-                        let code = REDIRECTS.get(code).map_or(code, AsRef::as_ref);
+                        let code = CODE_REDIRECTS.get(code).map_or(code, AsRef::as_ref);
                         if matches.contains(&code) || settings.external.contains(code) {
                             valid_codes.push(code.to_string());
                         } else {

src/check_tokens.rs

@@ -4,9 +4,9 @@ use rustpython_parser::lexer::{LexResult, Tok};
 
 use crate::checks::{Check, CheckCode};
 use crate::lex::docstring_detection::StateMachine;
-use crate::rules::checks::Context;
+use crate::ruff::checks::Context;
 use crate::source_code_locator::SourceCodeLocator;
-use crate::{eradicate, flake8_quotes, pycodestyle, rules, Settings};
+use crate::{eradicate, flake8_quotes, pycodestyle, ruff, Settings};
 
 pub fn check_tokens(
     locator: &SourceCodeLocator,
@@ -37,7 +37,7 @@ pub fn check_tokens(
         // RUF001, RUF002, RUF003
         if enforce_ambiguous_unicode_character {
             if matches!(tok, Tok::String { .. } | Tok::Comment) {
-                checks.extend(rules::checks::ambiguous_unicode_character(
+                checks.extend(ruff::checks::ambiguous_unicode_character(
                     locator,
                     start,
                     end,

src/checks.rs

@@ -10,6 +10,7 @@ use strum_macros::{AsRefStr, Display, EnumIter, EnumString};
 
 use crate::ast::types::Range;
 use crate::autofix::Fix;
+use crate::checks_gen::CheckCodePrefix;
 use crate::flake8_debugger::types::DebuggerUsingType;
 use crate::flake8_quotes::settings::Quote;
 use crate::flake8_tidy_imports::settings::Strictness;
@@ -86,22 +87,27 @@ pub enum CheckCode {
     F706,
     F707,
     F722,
+    F811,
     F821,
     F822,
     F823,
     F831,
     F841,
+    F842,
     F901,
     // pylint
     PLC0414,
     PLC2201,
     PLC3002,
+    PLE0117,
+    PLE0118,
     PLE1142,
     PLR0206,
     PLR0402,
     PLR1701,
     PLR1722,
     PLW0120,
+    PLW0602,
     // flake8-builtins
     A001,
     A002,
@@ -134,6 +140,7 @@ pub enum CheckCode {
     B026,
     B027,
     B904,
+    B905,
     // flake8-blind-except
     BLE001,
     // flake8-comprehensions
@@ -158,7 +165,7 @@ pub enum CheckCode {
     // mccabe
     C901,
     // flake8-tidy-imports
-    I252,
+    TID252,
     // flake8-return
     RET501,
     RET502,
@@ -199,6 +206,8 @@ pub enum CheckCode {
     YTT301,
     YTT302,
     YTT303,
+    // flake8-simplify
+    SIM118,
     // pyupgrade
     UP001,
     UP003,
@@ -240,6 +249,7 @@ pub enum CheckCode {
     D214,
     D215,
     D300,
+    D301,
     D400,
     D402,
     D403,
@@ -290,6 +300,14 @@ pub enum CheckCode {
     FBT001,
     FBT002,
     FBT003,
+    // flake8-unused-arguments
+    ARG001,
+    ARG002,
+    ARG003,
+    ARG004,
+    ARG005,
+    // flake8-import-conventions
+    ICN001,
     // Ruff
     RUF001,
     RUF002,
@@ -317,10 +335,13 @@ pub enum CheckCategory {
     Flake8Builtins,
     Flake8Comprehensions,
     Flake8Debugger,
+    Flake8ImportConventions,
     Flake8Print,
     Flake8Quotes,
     Flake8Return,
+    Flake8Simplify,
     Flake8TidyImports,
+    Flake8UnusedArguments,
     Eradicate,
     PygrepHooks,
     Pylint,
@@ -354,10 +375,13 @@ impl CheckCategory {
             CheckCategory::Flake8Builtins => "flake8-builtins",
             CheckCategory::Flake8Comprehensions => "flake8-comprehensions",
             CheckCategory::Flake8Debugger => "flake8-debugger",
+            CheckCategory::Flake8ImportConventions => "flake8-import-conventions",
             CheckCategory::Flake8Print => "flake8-print",
             CheckCategory::Flake8Quotes => "flake8-quotes",
             CheckCategory::Flake8Return => "flake8-return",
             CheckCategory::Flake8TidyImports => "flake8-tidy-imports",
+            CheckCategory::Flake8Simplify => "flake8-simplify",
+            CheckCategory::Flake8UnusedArguments => "flake8-unused-arguments",
             CheckCategory::Isort => "isort",
             CheckCategory::McCabe => "mccabe",
             CheckCategory::PEP8Naming => "pep8-naming",
@@ -371,6 +395,43 @@ impl CheckCategory {
         }
     }
 
+    pub fn codes(&self) -> Vec<CheckCodePrefix> {
+        match self {
+            CheckCategory::Eradicate => vec![CheckCodePrefix::ERA],
+            CheckCategory::Flake82020 => vec![CheckCodePrefix::YTT],
+            CheckCategory::Flake8Annotations => vec![CheckCodePrefix::ANN],
+            CheckCategory::Flake8Bandit => vec![CheckCodePrefix::S],
+            CheckCategory::Flake8BlindExcept => vec![CheckCodePrefix::BLE],
+            CheckCategory::Flake8BooleanTrap => vec![CheckCodePrefix::FBT],
+            CheckCategory::Flake8Bugbear => vec![CheckCodePrefix::B],
+            CheckCategory::Flake8Builtins => vec![CheckCodePrefix::A],
+            CheckCategory::Flake8Comprehensions => vec![CheckCodePrefix::C4],
+            CheckCategory::Flake8Debugger => vec![CheckCodePrefix::T10],
+            CheckCategory::Flake8Print => vec![CheckCodePrefix::T20],
+            CheckCategory::Flake8Quotes => vec![CheckCodePrefix::Q],
+            CheckCategory::Flake8Return => vec![CheckCodePrefix::RET],
+            CheckCategory::Flake8Simplify => vec![CheckCodePrefix::SIM],
+            CheckCategory::Flake8TidyImports => vec![CheckCodePrefix::TID],
+            CheckCategory::Flake8UnusedArguments => vec![CheckCodePrefix::ARG],
+            CheckCategory::Isort => vec![CheckCodePrefix::I],
+            CheckCategory::McCabe => vec![CheckCodePrefix::C90],
+            CheckCategory::PEP8Naming => vec![CheckCodePrefix::N],
+            CheckCategory::Pycodestyle => vec![CheckCodePrefix::E, CheckCodePrefix::W],
+            CheckCategory::Pydocstyle => vec![CheckCodePrefix::D],
+            CheckCategory::Pyflakes => vec![CheckCodePrefix::F],
+            CheckCategory::PygrepHooks => vec![CheckCodePrefix::PGH],
+            CheckCategory::Pylint => vec![
+                CheckCodePrefix::PLC,
+                CheckCodePrefix::PLE,
+                CheckCodePrefix::PLR,
+                CheckCodePrefix::PLW,
+            ],
+            CheckCategory::Pyupgrade => vec![CheckCodePrefix::UP],
+            CheckCategory::Flake8ImportConventions => vec![CheckCodePrefix::ICN],
+            CheckCategory::Ruff => vec![CheckCodePrefix::RUF],
+        }
+    }
+
     pub fn url(&self) -> Option<(&'static str, &'static Platform)> {
         match self {
             CheckCategory::Eradicate => {
@@ -412,6 +473,7 @@ impl CheckCategory {
                 "https://pypi.org/project/flake8-debugger/4.1.2/",
                 &Platform::PyPI,
             )),
+            CheckCategory::Flake8ImportConventions => None,
             CheckCategory::Flake8Print => Some((
                 "https://pypi.org/project/flake8-print/5.0.0/",
                 &Platform::PyPI,
@@ -424,10 +486,18 @@ impl CheckCategory {
                 "https://pypi.org/project/flake8-return/1.2.0/",
                 &Platform::PyPI,
             )),
+            CheckCategory::Flake8Simplify => Some((
+                "https://pypi.org/project/flake8-simplify/0.19.3/",
+                &Platform::PyPI,
+            )),
             CheckCategory::Flake8TidyImports => Some((
                 "https://pypi.org/project/flake8-tidy-imports/4.8.0/",
                 &Platform::PyPI,
             )),
+            CheckCategory::Flake8UnusedArguments => Some((
+                "https://pypi.org/project/flake8-unused-arguments/0.0.12/",
+                &Platform::PyPI,
+            )),
             CheckCategory::Isort => {
                 Some(("https://pypi.org/project/isort/5.10.1/", &Platform::PyPI))
             }
@@ -561,6 +631,7 @@ pub enum CheckKind {
     PercentFormatStarRequiresSequence,
     PercentFormatUnsupportedFormatCharacter(char),
     RaiseNotImplemented,
+    RedefinedWhileUnused(String, usize),
     ReturnOutsideFunction,
     StringDotFormatExtraNamedArguments(Vec<String>),
     StringDotFormatExtraPositionalArguments(Vec<String>),
@@ -570,26 +641,30 @@ pub enum CheckKind {
     TwoStarredExpressions,
     UndefinedExport(String),
     UndefinedLocal(String),
+    UnusedAnnotation(String),
     UndefinedName(String),
     UnusedImport(String, bool),
     UnusedVariable(String),
     YieldOutsideFunction(DeferralKeyword),
     // pylint
-    ConsiderMergingIsinstance(String, Vec<String>),
-    UselessImportAlias,
-    MisplacedComparisonConstant(String),
-    UnnecessaryDirectLambdaCall,
-    PropertyWithParameters,
-    ConsiderUsingFromImport(String, String),
     AwaitOutsideAsync,
+    ConsiderMergingIsinstance(String, Vec<String>),
+    ConsiderUsingFromImport(String, String),
+    GlobalVariableNotAssigned(String),
+    MisplacedComparisonConstant(String),
+    NonlocalWithoutBinding(String),
+    PropertyWithParameters,
+    UnnecessaryDirectLambdaCall,
+    UseSysExit(String),
+    UsedPriorGlobalDeclaration(String, usize),
     UselessElseOnLoop,
-    ConsiderUsingSysExit,
+    UselessImportAlias,
     // flake8-builtins
     BuiltinVariableShadowing(String),
     BuiltinArgumentShadowing(String),
     BuiltinAttributeShadowing(String),
     // flake8-blind-except
-    BlindExcept,
+    BlindExcept(String),
     // flake8-bugbear
     AbstractBaseClassWithoutAbstractMethod(String),
     AssignmentToOsEnviron,
@@ -618,6 +693,7 @@ pub enum CheckKind {
     UselessComparison,
     UselessContextlibSuppress,
     UselessExpression,
+    ZipWithoutExplicitStrict,
     // flake8-comprehensions
     UnnecessaryGeneratorList,
     UnnecessaryGeneratorSet,
@@ -679,6 +755,8 @@ pub enum CheckKind {
     SysVersion0Referenced,
     SysVersionCmpStr10,
     SysVersionSlice1Referenced,
+    // flake8-simplify
+    KeyInDict(String, String),
     // pyupgrade
     TypeOfPrimitive(Primitive),
     UselessMetaclassType,
@@ -738,6 +816,7 @@ pub enum CheckKind {
     SectionUnderlineMatchesSectionLength(String),
     SectionUnderlineNotOverIndented(String),
     SkipDocstring,
+    UsesRPrefixForBackslashedContent,
     UsesTripleQuotes,
     // pep8-naming
     InvalidClassName(String),
@@ -774,6 +853,14 @@ pub enum CheckKind {
     BooleanPositionalValueInFunctionCall,
     // pygrep-hooks
     NoEval,
+    // flake8-unused-arguments
+    UnusedFunctionArgument(String),
+    UnusedMethodArgument(String),
+    UnusedClassMethodArgument(String),
+    UnusedStaticMethodArgument(String),
+    UnusedLambdaArgument(String),
+    // flake8-import-conventions
+    ImportAliasIsNotConventional(String, String),
     // Ruff
     AmbiguousUnicodeCharacterString(char, char),
     AmbiguousUnicodeCharacterDocstring(char, char),
@@ -868,16 +955,20 @@ impl CheckCode {
             CheckCode::F706 => CheckKind::ReturnOutsideFunction,
             CheckCode::F707 => CheckKind::DefaultExceptNotLast,
             CheckCode::F722 => CheckKind::ForwardAnnotationSyntaxError("...".to_string()),
+            CheckCode::F811 => CheckKind::RedefinedWhileUnused("...".to_string(), 1),
             CheckCode::F821 => CheckKind::UndefinedName("...".to_string()),
             CheckCode::F822 => CheckKind::UndefinedExport("...".to_string()),
             CheckCode::F823 => CheckKind::UndefinedLocal("...".to_string()),
             CheckCode::F831 => CheckKind::DuplicateArgumentName,
             CheckCode::F841 => CheckKind::UnusedVariable("...".to_string()),
+            CheckCode::F842 => CheckKind::UnusedAnnotation("...".to_string()),
             CheckCode::F901 => CheckKind::RaiseNotImplemented,
             // pylint
             CheckCode::PLC0414 => CheckKind::UselessImportAlias,
             CheckCode::PLC2201 => CheckKind::MisplacedComparisonConstant("...".to_string()),
             CheckCode::PLC3002 => CheckKind::UnnecessaryDirectLambdaCall,
+            CheckCode::PLE0117 => CheckKind::NonlocalWithoutBinding("...".to_string()),
+            CheckCode::PLE0118 => CheckKind::UsedPriorGlobalDeclaration("...".to_string(), 1),
             CheckCode::PLE1142 => CheckKind::AwaitOutsideAsync,
             CheckCode::PLR0402 => {
                 CheckKind::ConsiderUsingFromImport("...".to_string(), "...".to_string())
@@ -886,8 +977,9 @@ impl CheckCode {
             CheckCode::PLR1701 => {
                 CheckKind::ConsiderMergingIsinstance("...".to_string(), vec!["...".to_string()])
             }
-            CheckCode::PLR1722 => CheckKind::ConsiderUsingSysExit,
+            CheckCode::PLR1722 => CheckKind::UseSysExit("exit".to_string()),
             CheckCode::PLW0120 => CheckKind::UselessElseOnLoop,
+            CheckCode::PLW0602 => CheckKind::GlobalVariableNotAssigned("...".to_string()),
             // flake8-builtins
             CheckCode::A001 => CheckKind::BuiltinVariableShadowing("...".to_string()),
             CheckCode::A002 => CheckKind::BuiltinArgumentShadowing("...".to_string()),
@@ -924,6 +1016,7 @@ impl CheckCode {
             CheckCode::B026 => CheckKind::StarArgUnpackingAfterKeywordArg,
             CheckCode::B027 => CheckKind::EmptyMethodWithoutAbstractDecorator("...".to_string()),
             CheckCode::B904 => CheckKind::RaiseWithoutFromInsideExcept,
+            CheckCode::B905 => CheckKind::ZipWithoutExplicitStrict,
             // flake8-comprehensions
             CheckCode::C400 => CheckKind::UnnecessaryGeneratorList,
             CheckCode::C401 => CheckKind::UnnecessaryGeneratorSet,
@@ -957,7 +1050,7 @@ impl CheckCode {
             // flake8-debugger
             CheckCode::T100 => CheckKind::Debugger(DebuggerUsingType::Import("...".to_string())),
             // flake8-tidy-imports
-            CheckCode::I252 => CheckKind::BannedRelativeImport(Strictness::All),
+            CheckCode::TID252 => CheckKind::BannedRelativeImport(Strictness::All),
             // flake8-return
             CheckCode::RET501 => CheckKind::UnnecessaryReturnNone,
             CheckCode::RET502 => CheckKind::ImplicitReturnValue,
@@ -999,7 +1092,9 @@ impl CheckCode {
             CheckCode::YTT302 => CheckKind::SysVersionCmpStr10,
             CheckCode::YTT303 => CheckKind::SysVersionSlice1Referenced,
             // flake8-blind-except
-            CheckCode::BLE001 => CheckKind::BlindExcept,
+            CheckCode::BLE001 => CheckKind::BlindExcept("Exception".to_string()),
+            // flake8-simplify
+            CheckCode::SIM118 => CheckKind::KeyInDict("key".to_string(), "dict".to_string()),
             // pyupgrade
             CheckCode::UP001 => CheckKind::UselessMetaclassType,
             CheckCode::UP003 => CheckKind::TypeOfPrimitive(Primitive::Str),
@@ -1044,6 +1139,7 @@ impl CheckCode {
             CheckCode::D214 => CheckKind::SectionNotOverIndented("Returns".to_string()),
             CheckCode::D215 => CheckKind::SectionUnderlineNotOverIndented("Returns".to_string()),
             CheckCode::D300 => CheckKind::UsesTripleQuotes,
+            CheckCode::D301 => CheckKind::UsesRPrefixForBackslashedContent,
             CheckCode::D400 => CheckKind::EndsInPeriod,
             CheckCode::D402 => CheckKind::NoSignature,
             CheckCode::D403 => CheckKind::FirstLineCapitalized,
@@ -1113,6 +1209,16 @@ impl CheckCode {
             CheckCode::FBT003 => CheckKind::BooleanPositionalValueInFunctionCall,
             // pygrep-hooks
             CheckCode::PGH001 => CheckKind::NoEval,
+            // flake8-unused-arguments
+            CheckCode::ARG001 => CheckKind::UnusedFunctionArgument("...".to_string()),
+            CheckCode::ARG002 => CheckKind::UnusedMethodArgument("...".to_string()),
+            CheckCode::ARG003 => CheckKind::UnusedClassMethodArgument("...".to_string()),
+            CheckCode::ARG004 => CheckKind::UnusedStaticMethodArgument("...".to_string()),
+            CheckCode::ARG005 => CheckKind::UnusedLambdaArgument("...".to_string()),
+            // flake8-import-conventions
+            CheckCode::ICN001 => {
+                CheckKind::ImportAliasIsNotConventional("...".to_string(), "...".to_string())
+            }
             // Ruff
             CheckCode::RUF001 => CheckKind::AmbiguousUnicodeCharacterString('𝐁', 'B'),
             CheckCode::RUF002 => CheckKind::AmbiguousUnicodeCharacterDocstring('𝐁', 'B'),
@@ -1138,6 +1244,11 @@ impl CheckCode {
             CheckCode::ANN205 => CheckCategory::Flake8Annotations,
             CheckCode::ANN206 => CheckCategory::Flake8Annotations,
             CheckCode::ANN401 => CheckCategory::Flake8Annotations,
+            CheckCode::ARG001 => CheckCategory::Flake8UnusedArguments,
+            CheckCode::ARG002 => CheckCategory::Flake8UnusedArguments,
+            CheckCode::ARG003 => CheckCategory::Flake8UnusedArguments,
+            CheckCode::ARG004 => CheckCategory::Flake8UnusedArguments,
+            CheckCode::ARG005 => CheckCategory::Flake8UnusedArguments,
             CheckCode::B002 => CheckCategory::Flake8Bugbear,
             CheckCode::B003 => CheckCategory::Flake8Bugbear,
             CheckCode::B004 => CheckCategory::Flake8Bugbear,
@@ -1165,6 +1276,7 @@ impl CheckCode {
             CheckCode::B026 => CheckCategory::Flake8Bugbear,
             CheckCode::B027 => CheckCategory::Flake8Bugbear,
             CheckCode::B904 => CheckCategory::Flake8Bugbear,
+            CheckCode::B905 => CheckCategory::Flake8Bugbear,
             CheckCode::BLE001 => CheckCategory::Flake8BlindExcept,
             CheckCode::C400 => CheckCategory::Flake8Comprehensions,
             CheckCode::C401 => CheckCategory::Flake8Comprehensions,
@@ -1208,6 +1320,7 @@ impl CheckCode {
             CheckCode::D214 => CheckCategory::Pydocstyle,
             CheckCode::D215 => CheckCategory::Pydocstyle,
             CheckCode::D300 => CheckCategory::Pydocstyle,
+            CheckCode::D301 => CheckCategory::Pydocstyle,
             CheckCode::D400 => CheckCategory::Pydocstyle,
             CheckCode::D402 => CheckCategory::Pydocstyle,
             CheckCode::D403 => CheckCategory::Pydocstyle,
@@ -1278,17 +1391,20 @@ impl CheckCode {
             CheckCode::F706 => CheckCategory::Pyflakes,
             CheckCode::F707 => CheckCategory::Pyflakes,
             CheckCode::F722 => CheckCategory::Pyflakes,
+            CheckCode::F811 => CheckCategory::Pyflakes,
             CheckCode::F821 => CheckCategory::Pyflakes,
             CheckCode::F822 => CheckCategory::Pyflakes,
             CheckCode::F823 => CheckCategory::Pyflakes,
             CheckCode::F831 => CheckCategory::Pyflakes,
             CheckCode::F841 => CheckCategory::Pyflakes,
+            CheckCode::F842 => CheckCategory::Pyflakes,
             CheckCode::F901 => CheckCategory::Pyflakes,
             CheckCode::FBT001 => CheckCategory::Flake8BooleanTrap,
             CheckCode::FBT002 => CheckCategory::Flake8BooleanTrap,
             CheckCode::FBT003 => CheckCategory::Flake8BooleanTrap,
             CheckCode::I001 => CheckCategory::Isort,
-            CheckCode::I252 => CheckCategory::Flake8TidyImports,
+            CheckCode::TID252 => CheckCategory::Flake8TidyImports,
+            CheckCode::ICN001 => CheckCategory::Flake8ImportConventions,
             CheckCode::N801 => CheckCategory::PEP8Naming,
             CheckCode::N802 => CheckCategory::PEP8Naming,
             CheckCode::N803 => CheckCategory::PEP8Naming,
@@ -1308,12 +1424,15 @@ impl CheckCode {
             CheckCode::PLC0414 => CheckCategory::Pylint,
             CheckCode::PLC2201 => CheckCategory::Pylint,
             CheckCode::PLC3002 => CheckCategory::Pylint,
+            CheckCode::PLE0117 => CheckCategory::Pylint,
+            CheckCode::PLE0118 => CheckCategory::Pylint,
             CheckCode::PLE1142 => CheckCategory::Pylint,
             CheckCode::PLR0206 => CheckCategory::Pylint,
             CheckCode::PLR0402 => CheckCategory::Pylint,
             CheckCode::PLR1701 => CheckCategory::Pylint,
             CheckCode::PLR1722 => CheckCategory::Pylint,
             CheckCode::PLW0120 => CheckCategory::Pylint,
+            CheckCode::PLW0602 => CheckCategory::Pylint,
             CheckCode::Q000 => CheckCategory::Flake8Quotes,
             CheckCode::Q001 => CheckCategory::Flake8Quotes,
             CheckCode::Q002 => CheckCategory::Flake8Quotes,
@@ -1336,6 +1455,7 @@ impl CheckCode {
             CheckCode::S105 => CheckCategory::Flake8Bandit,
             CheckCode::S106 => CheckCategory::Flake8Bandit,
             CheckCode::S107 => CheckCategory::Flake8Bandit,
+            CheckCode::SIM118 => CheckCategory::Flake8Simplify,
             CheckCode::T100 => CheckCategory::Flake8Debugger,
             CheckCode::T201 => CheckCategory::Flake8Print,
             CheckCode::T203 => CheckCategory::Flake8Print,
@@ -1426,23 +1546,28 @@ impl CheckKind {
             CheckKind::TypeComparison => &CheckCode::E721,
             CheckKind::UndefinedExport(_) => &CheckCode::F822,
             CheckKind::UndefinedLocal(_) => &CheckCode::F823,
+            CheckKind::RedefinedWhileUnused(..) => &CheckCode::F811,
             CheckKind::UndefinedName(_) => &CheckCode::F821,
             CheckKind::UnusedImport(..) => &CheckCode::F401,
             CheckKind::UnusedVariable(_) => &CheckCode::F841,
+            CheckKind::UnusedAnnotation(_) => &CheckCode::F842,
             CheckKind::YieldOutsideFunction(_) => &CheckCode::F704,
             // pycodestyle warnings
             CheckKind::NoNewLineAtEndOfFile => &CheckCode::W292,
             CheckKind::InvalidEscapeSequence(_) => &CheckCode::W605,
             // pylint
-            CheckKind::UselessImportAlias => &CheckCode::PLC0414,
-            CheckKind::MisplacedComparisonConstant(..) => &CheckCode::PLC2201,
-            CheckKind::UnnecessaryDirectLambdaCall => &CheckCode::PLC3002,
             CheckKind::AwaitOutsideAsync => &CheckCode::PLE1142,
             CheckKind::ConsiderMergingIsinstance(..) => &CheckCode::PLR1701,
-            CheckKind::PropertyWithParameters => &CheckCode::PLR0206,
             CheckKind::ConsiderUsingFromImport(..) => &CheckCode::PLR0402,
-            CheckKind::ConsiderUsingSysExit => &CheckCode::PLR1722,
+            CheckKind::GlobalVariableNotAssigned(..) => &CheckCode::PLW0602,
+            CheckKind::MisplacedComparisonConstant(..) => &CheckCode::PLC2201,
+            CheckKind::PropertyWithParameters => &CheckCode::PLR0206,
+            CheckKind::UnnecessaryDirectLambdaCall => &CheckCode::PLC3002,
+            CheckKind::UseSysExit(_) => &CheckCode::PLR1722,
+            CheckKind::NonlocalWithoutBinding(..) => &CheckCode::PLE0117,
+            CheckKind::UsedPriorGlobalDeclaration(..) => &CheckCode::PLE0118,
             CheckKind::UselessElseOnLoop => &CheckCode::PLW0120,
+            CheckKind::UselessImportAlias => &CheckCode::PLC0414,
             // flake8-builtins
             CheckKind::BuiltinVariableShadowing(_) => &CheckCode::A001,
             CheckKind::BuiltinArgumentShadowing(_) => &CheckCode::A002,
@@ -1465,6 +1590,7 @@ impl CheckKind {
             CheckKind::MutableArgumentDefault => &CheckCode::B006,
             CheckKind::NoAssertRaisesException => &CheckCode::B017,
             CheckKind::RaiseWithoutFromInsideExcept => &CheckCode::B904,
+            CheckKind::ZipWithoutExplicitStrict => &CheckCode::B905,
             CheckKind::RedundantTupleInExceptionHandler(_) => &CheckCode::B013,
             CheckKind::SetAttrWithConstant => &CheckCode::B010,
             CheckKind::StarArgUnpackingAfterKeywordArg => &CheckCode::B026,
@@ -1476,7 +1602,7 @@ impl CheckKind {
             CheckKind::UselessContextlibSuppress => &CheckCode::B022,
             CheckKind::UselessExpression => &CheckCode::B018,
             // flake8-blind-except
-            CheckKind::BlindExcept => &CheckCode::BLE001,
+            CheckKind::BlindExcept(_) => &CheckCode::BLE001,
             // flake8-comprehensions
             CheckKind::UnnecessaryGeneratorList => &CheckCode::C400,
             CheckKind::UnnecessaryGeneratorSet => &CheckCode::C401,
@@ -1497,7 +1623,7 @@ impl CheckKind {
             // flake8-debugger
             CheckKind::Debugger(_) => &CheckCode::T100,
             // flake8-tidy-imports
-            CheckKind::BannedRelativeImport(_) => &CheckCode::I252,
+            CheckKind::BannedRelativeImport(_) => &CheckCode::TID252,
             // flake8-return
             CheckKind::UnnecessaryReturnNone => &CheckCode::RET501,
             CheckKind::ImplicitReturnValue => &CheckCode::RET502,
@@ -1538,6 +1664,8 @@ impl CheckKind {
             CheckKind::SysVersion0Referenced => &CheckCode::YTT301,
             CheckKind::SysVersionCmpStr10 => &CheckCode::YTT302,
             CheckKind::SysVersionSlice1Referenced => &CheckCode::YTT303,
+            // flake8-simplify
+            CheckKind::KeyInDict(..) => &CheckCode::SIM118,
             // pyupgrade
             CheckKind::TypeOfPrimitive(_) => &CheckCode::UP003,
             CheckKind::UselessMetaclassType => &CheckCode::UP001,
@@ -1597,6 +1725,7 @@ impl CheckKind {
             CheckKind::SectionUnderlineMatchesSectionLength(_) => &CheckCode::D409,
             CheckKind::SectionUnderlineNotOverIndented(_) => &CheckCode::D215,
             CheckKind::SkipDocstring => &CheckCode::D418,
+            CheckKind::UsesRPrefixForBackslashedContent => &CheckCode::D301,
             CheckKind::UsesTripleQuotes => &CheckCode::D300,
             // pep8-naming
             CheckKind::InvalidClassName(_) => &CheckCode::N801,
@@ -1633,6 +1762,14 @@ impl CheckKind {
             CheckKind::BooleanPositionalValueInFunctionCall => &CheckCode::FBT003,
             // pygrep-hooks
             CheckKind::NoEval => &CheckCode::PGH001,
+            // flake8-unused-arguments
+            CheckKind::UnusedFunctionArgument(..) => &CheckCode::ARG001,
+            CheckKind::UnusedMethodArgument(..) => &CheckCode::ARG002,
+            CheckKind::UnusedClassMethodArgument(..) => &CheckCode::ARG003,
+            CheckKind::UnusedStaticMethodArgument(..) => &CheckCode::ARG004,
+            CheckKind::UnusedLambdaArgument(..) => &CheckCode::ARG005,
+            // flake8-import-conventions
+            CheckKind::ImportAliasIsNotConventional(..) => &CheckCode::ICN001,
             // Ruff
             CheckKind::AmbiguousUnicodeCharacterString(..) => &CheckCode::RUF001,
             CheckKind::AmbiguousUnicodeCharacterDocstring(..) => &CheckCode::RUF002,
@@ -1755,6 +1892,9 @@ impl CheckKind {
             CheckKind::RaiseNotImplemented => {
                 "`raise NotImplemented` should be `raise NotImplementedError`".to_string()
             }
+            CheckKind::RedefinedWhileUnused(name, line) => {
+                format!("Redefinition of unused `{name}` from line {line}")
+            }
             CheckKind::ReturnOutsideFunction => {
                 "`return` statement outside of a function/method".to_string()
             }
@@ -1803,6 +1943,9 @@ impl CheckKind {
             CheckKind::UndefinedName(name) => {
                 format!("Undefined name `{name}`")
             }
+            CheckKind::UnusedAnnotation(name) => {
+                format!("Local variable `{name}` is annotated but never used")
+            }
             CheckKind::UnusedImport(name, ignore_init) => {
                 if *ignore_init {
                     format!(
@@ -1830,10 +1973,13 @@ impl CheckKind {
             }
             CheckKind::ConsiderMergingIsinstance(obj, types) => {
                 let types = types.join(", ");
-                format!("Consider merging these isinstance calls: `isinstance({obj}, ({types}))`")
+                format!("Merge these isinstance calls: `isinstance({obj}, ({types}))`")
             }
-            CheckKind::MisplacedComparisonConstant(comprison) => {
-                format!("Comparison should be {comprison}")
+            CheckKind::MisplacedComparisonConstant(comparison) => {
+                format!("Comparison should be {comparison}")
+            }
+            CheckKind::NonlocalWithoutBinding(name) => {
+                format!("Nonlocal name `{name}` found without binding")
             }
             CheckKind::UnnecessaryDirectLambdaCall => "Lambda expression called directly. Execute \
                                                        the expression inline instead."
@@ -1842,7 +1988,13 @@ impl CheckKind {
                 "Cannot have defined parameters for properties".to_string()
             }
             CheckKind::ConsiderUsingFromImport(module, name) => {
-                format!("Consider using `from {module} import {name}`")
+                format!("Use `from {module} import {name}` in lieu of alias")
+            }
+            CheckKind::UsedPriorGlobalDeclaration(name, line) => {
+                format!("Name `{name}` is used prior to global declaration on line {line}")
+            }
+            CheckKind::GlobalVariableNotAssigned(name) => {
+                format!("Using global for `{name}` but no assignment is done")
             }
             CheckKind::AwaitOutsideAsync => {
                 "`await` should be used within an async function".to_string()
@@ -1850,7 +2002,7 @@ impl CheckKind {
             CheckKind::UselessElseOnLoop => "Else clause on loop without a break statement, \
                                              remove the else and de-indent all the code inside it"
                 .to_string(),
-            CheckKind::ConsiderUsingSysExit => "Consider using `sys.exit()`".to_string(),
+            CheckKind::UseSysExit(name) => format!("Use `sys.exit()` instead of `{name}`"),
             // flake8-builtins
             CheckKind::BuiltinVariableShadowing(name) => {
                 format!("Variable `{name}` is shadowing a python builtin")
@@ -1976,6 +2128,9 @@ impl CheckKind {
                  from None to distinguish them from errors in exception handling"
                     .to_string()
             }
+            CheckKind::ZipWithoutExplicitStrict => {
+                "`zip()` without an explicit `strict=` parameter".to_string()
+            }
             // flake8-comprehensions
             CheckKind::UnnecessaryGeneratorList => {
                 "Unnecessary generator (rewrite as a `list` comprehension)".to_string()
@@ -2177,6 +2332,10 @@ impl CheckKind {
             CheckKind::SysVersionSlice1Referenced => {
                 "`sys.version[:1]` referenced (python10), use `sys.version_info`".to_string()
             }
+            // flake8-simplify
+            CheckKind::KeyInDict(key, dict) => {
+                format!("Use '{key} in {dict}' instead of '{key} in {dict}.keys()")
+            }
             // pyupgrade
             CheckKind::TypeOfPrimitive(primitive) => {
                 format!("Use `{}` instead of `type(...)`", primitive.builtin())
@@ -2238,6 +2397,9 @@ impl CheckKind {
             CheckKind::FirstLineCapitalized => {
                 "First word of the first line should be properly capitalized".to_string()
             }
+            CheckKind::UsesRPrefixForBackslashedContent => {
+                r#"Use r""" if any backslashes in a docstring"#.to_string()
+            }
             CheckKind::UsesTripleQuotes => r#"Use """triple double quotes""""#.to_string(),
             CheckKind::MultiLineSummaryFirstLine => {
                 "Multi-line docstring summary should start at the first line".to_string()
@@ -2402,7 +2564,7 @@ impl CheckKind {
                 format!("Possible hardcoded password: `\"{string}\"`")
             }
             // flake8-blind-except
-            CheckKind::BlindExcept => "Blind except Exception: statement".to_string(),
+            CheckKind::BlindExcept(name) => format!("Do not catch blind exception: `{name}`"),
             // mccabe
             CheckKind::FunctionIsTooComplex(name, complexity) => {
                 format!("`{name}` is too complex ({complexity})")
@@ -2419,6 +2581,22 @@ impl CheckKind {
             }
             // pygrep-hooks
             CheckKind::NoEval => "No builtin `eval()` allowed".to_string(),
+            // flake8-unused-arguments
+            CheckKind::UnusedFunctionArgument(name) => {
+                format!("Unused function argument: `{name}`")
+            }
+            CheckKind::UnusedMethodArgument(name) => format!("Unused method argument: `{name}`"),
+            CheckKind::UnusedClassMethodArgument(name) => {
+                format!("Unused class method argument: `{name}`")
+            }
+            CheckKind::UnusedStaticMethodArgument(name) => {
+                format!("Unused static method argument: `{name}`")
+            }
+            CheckKind::UnusedLambdaArgument(name) => format!("Unused lambda argument: `{name}`"),
+            // flake8-import-conventions
+            CheckKind::ImportAliasIsNotConventional(name, asname) => {
+                format!("`{name}` should be imported as `{asname}`")
+            }
             // Ruff
             CheckKind::AmbiguousUnicodeCharacterString(confusable, representant) => {
                 format!(
@@ -2489,7 +2667,6 @@ impl CheckKind {
                 | CheckKind::BlankLineBeforeSection(..)
                 | CheckKind::CapitalizeSectionName(..)
                 | CheckKind::CommentedOutCode
-                | CheckKind::ConsiderUsingSysExit
                 | CheckKind::ConvertNamedTupleFunctionalToClass(..)
                 | CheckKind::ConvertTypedDictFunctionalToClass(..)
                 | CheckKind::DashedUnderlineAfterSection(..)
@@ -2497,10 +2674,13 @@ impl CheckKind {
                 | CheckKind::DoNotAssertFalse
                 | CheckKind::DoNotAssignLambda
                 | CheckKind::DuplicateHandlerException(..)
+                | CheckKind::EndsInPeriod
+                | CheckKind::EndsInPunctuation
                 | CheckKind::GetAttrWithConstant
                 | CheckKind::ImplicitReturn
                 | CheckKind::ImplicitReturnValue
                 | CheckKind::IsLiteral
+                | CheckKind::KeyInDict(..)
                 | CheckKind::MisplacedComparisonConstant(..)
                 | CheckKind::NewLineAfterLastParagraph
                 | CheckKind::NewLineAfterSectionName(..)
@@ -2516,6 +2696,7 @@ impl CheckKind {
                 | CheckKind::NotIsTest
                 | CheckKind::OneBlankLineAfterClass(..)
                 | CheckKind::OneBlankLineBeforeClass(..)
+                | CheckKind::PercentFormatExtraNamedArguments(..)
                 | CheckKind::PEP3120UnnecessaryCodingComment
                 | CheckKind::PPrintFound
                 | CheckKind::PrintFound
@@ -2528,9 +2709,11 @@ impl CheckKind {
                 | CheckKind::SectionUnderlineMatchesSectionLength(..)
                 | CheckKind::SectionUnderlineNotOverIndented(..)
                 | CheckKind::SetAttrWithConstant
+                | CheckKind::StringDotFormatExtraNamedArguments(..)
                 | CheckKind::SuperCallWithParameters
                 | CheckKind::TrueFalseComparison(..)
                 | CheckKind::TypeOfPrimitive(..)
+                | CheckKind::UnnecessaryCallAroundSorted(..)
                 | CheckKind::UnnecessaryCollectionCall(..)
                 | CheckKind::UnnecessaryComprehension(..)
                 | CheckKind::UnnecessaryEncodeUTF8
@@ -2553,6 +2736,7 @@ impl CheckKind {
                 | CheckKind::UnusedNOQA(..)
                 | CheckKind::UsePEP585Annotation(..)
                 | CheckKind::UsePEP604Annotation
+                | CheckKind::UseSysExit(..)
                 | CheckKind::UselessImportAlias
                 | CheckKind::UselessMetaclassType
                 | CheckKind::UselessObjectInheritance(..)
@@ -2584,7 +2768,7 @@ impl Check {
 }
 
 /// A hash map from deprecated to latest `CheckCode`.
-pub static REDIRECTS: Lazy<FxHashMap<&'static str, CheckCode>> = Lazy::new(|| {
+pub static CODE_REDIRECTS: Lazy<FxHashMap<&'static str, CheckCode>> = Lazy::new(|| {
     FxHashMap::from_iter([
         // TODO(charlie): Remove by 2023-01-01.
         ("U001", CheckCode::UP001),
@@ -2601,6 +2785,25 @@ pub static REDIRECTS: Lazy<FxHashMap<&'static str, CheckCode>> = Lazy::new(|| {
         ("U013", CheckCode::UP013),
         ("U014", CheckCode::UP014),
         ("U015", CheckCode::UP015),
+        // TODO(charlie): Remove by 2023-02-01.
+        ("I252", CheckCode::TID252),
+        ("M001", CheckCode::RUF100),
+    ])
+});
+
+/// A hash map from deprecated `CheckCodePrefix` to latest `CheckCodePrefix`.
+pub static PREFIX_REDIRECTS: Lazy<FxHashMap<&'static str, &'static str>> = Lazy::new(|| {
+    FxHashMap::from_iter([
+        // TODO(charlie): Remove by 2023-01-01.
+        ("U", "UP"),
+        ("U0", "UP0"),
+        ("U00", "UP00"),
+        ("U01", "UP01"),
+        // TODO(charlie): Remove by 2023-02-01.
+        ("I2", "TID2"),
+        ("I25", "TID25"),
+        ("M", "RUF100"),
+        ("M0", "RUF100"),
     ])
 });
 

src/checks_gen.rs

@@ -2,11 +2,13 @@
 
 use colored::Colorize;
 use serde::{Deserialize, Serialize};
-use strum_macros::EnumString;
+use strum_macros::{AsRefStr, EnumString};
 
 use crate::checks::CheckCode;
 
-#[derive(EnumString, Debug, PartialEq, Eq, PartialOrd, Ord, Clone, Serialize, Deserialize)]
+#[derive(
+    EnumString, AsRefStr, Debug, PartialEq, Eq, PartialOrd, Ord, Clone, Serialize, Deserialize,
+)]
 pub enum CheckCodePrefix {
     A,
     A0,
@@ -34,6 +36,14 @@ pub enum CheckCodePrefix {
     ANN4,
     ANN40,
     ANN401,
+    ARG,
+    ARG0,
+    ARG00,
+    ARG001,
+    ARG002,
+    ARG003,
+    ARG004,
+    ARG005,
     B,
     B0,
     B00,
@@ -68,6 +78,7 @@ pub enum CheckCodePrefix {
     B9,
     B90,
     B904,
+    B905,
     BLE,
     BLE0,
     BLE00,
@@ -128,6 +139,7 @@ pub enum CheckCodePrefix {
     D3,
     D30,
     D300,
+    D301,
     D4,
     D40,
     D400,
@@ -232,6 +244,8 @@ pub enum CheckCodePrefix {
     F72,
     F722,
     F8,
+    F81,
+    F811,
     F82,
     F821,
     F822,
@@ -240,6 +254,7 @@ pub enum CheckCodePrefix {
     F831,
     F84,
     F841,
+    F842,
     F9,
     F90,
     F901,
@@ -256,6 +271,13 @@ pub enum CheckCodePrefix {
     I2,
     I25,
     I252,
+    ICN,
+    ICN0,
+    ICN00,
+    ICN001,
+    M,
+    M0,
+    M001,
     N,
     N8,
     N80,
@@ -293,6 +315,11 @@ pub enum CheckCodePrefix {
     PLC300,
     PLC3002,
     PLE,
+    PLE0,
+    PLE01,
+    PLE011,
+    PLE0117,
+    PLE0118,
     PLE1,
     PLE11,
     PLE114,
@@ -316,6 +343,9 @@ pub enum CheckCodePrefix {
     PLW01,
     PLW012,
     PLW0120,
+    PLW06,
+    PLW060,
+    PLW0602,
     Q,
     Q0,
     Q00,
@@ -352,6 +382,10 @@ pub enum CheckCodePrefix {
     S105,
     S106,
     S107,
+    SIM,
+    SIM1,
+    SIM11,
+    SIM118,
     T,
     T1,
     T10,
@@ -360,6 +394,10 @@ pub enum CheckCodePrefix {
     T20,
     T201,
     T203,
+    TID,
+    TID2,
+    TID25,
+    TID252,
     U,
     U0,
     U00,
@@ -485,6 +523,32 @@ impl CheckCodePrefix {
             CheckCodePrefix::ANN4 => vec![CheckCode::ANN401],
             CheckCodePrefix::ANN40 => vec![CheckCode::ANN401],
             CheckCodePrefix::ANN401 => vec![CheckCode::ANN401],
+            CheckCodePrefix::ARG => vec![
+                CheckCode::ARG001,
+                CheckCode::ARG002,
+                CheckCode::ARG003,
+                CheckCode::ARG004,
+                CheckCode::ARG005,
+            ],
+            CheckCodePrefix::ARG0 => vec![
+                CheckCode::ARG001,
+                CheckCode::ARG002,
+                CheckCode::ARG003,
+                CheckCode::ARG004,
+                CheckCode::ARG005,
+            ],
+            CheckCodePrefix::ARG00 => vec![
+                CheckCode::ARG001,
+                CheckCode::ARG002,
+                CheckCode::ARG003,
+                CheckCode::ARG004,
+                CheckCode::ARG005,
+            ],
+            CheckCodePrefix::ARG001 => vec![CheckCode::ARG001],
+            CheckCodePrefix::ARG002 => vec![CheckCode::ARG002],
+            CheckCodePrefix::ARG003 => vec![CheckCode::ARG003],
+            CheckCodePrefix::ARG004 => vec![CheckCode::ARG004],
+            CheckCodePrefix::ARG005 => vec![CheckCode::ARG005],
             CheckCodePrefix::B => vec![
                 CheckCode::B002,
                 CheckCode::B003,
@@ -513,6 +577,7 @@ impl CheckCodePrefix {
                 CheckCode::B026,
                 CheckCode::B027,
                 CheckCode::B904,
+                CheckCode::B905,
             ],
             CheckCodePrefix::B0 => vec![
                 CheckCode::B002,
@@ -600,9 +665,10 @@ impl CheckCodePrefix {
             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::B9 => vec![CheckCode::B904, CheckCode::B905],
+            CheckCodePrefix::B90 => vec![CheckCode::B904, CheckCode::B905],
             CheckCodePrefix::B904 => vec![CheckCode::B904],
+            CheckCodePrefix::B905 => vec![CheckCode::B905],
             CheckCodePrefix::BLE => vec![CheckCode::BLE001],
             CheckCodePrefix::BLE0 => vec![CheckCode::BLE001],
             CheckCodePrefix::BLE00 => vec![CheckCode::BLE001],
@@ -709,6 +775,7 @@ impl CheckCodePrefix {
                 CheckCode::D214,
                 CheckCode::D215,
                 CheckCode::D300,
+                CheckCode::D301,
                 CheckCode::D400,
                 CheckCode::D402,
                 CheckCode::D403,
@@ -811,9 +878,10 @@ impl CheckCodePrefix {
             CheckCodePrefix::D213 => vec![CheckCode::D213],
             CheckCodePrefix::D214 => vec![CheckCode::D214],
             CheckCodePrefix::D215 => vec![CheckCode::D215],
-            CheckCodePrefix::D3 => vec![CheckCode::D300],
-            CheckCodePrefix::D30 => vec![CheckCode::D300],
+            CheckCodePrefix::D3 => vec![CheckCode::D300, CheckCode::D301],
+            CheckCodePrefix::D30 => vec![CheckCode::D300, CheckCode::D301],
             CheckCodePrefix::D300 => vec![CheckCode::D300],
+            CheckCodePrefix::D301 => vec![CheckCode::D301],
             CheckCodePrefix::D4 => vec![
                 CheckCode::D400,
                 CheckCode::D402,
@@ -976,11 +1044,13 @@ impl CheckCodePrefix {
                 CheckCode::F706,
                 CheckCode::F707,
                 CheckCode::F722,
+                CheckCode::F811,
                 CheckCode::F821,
                 CheckCode::F822,
                 CheckCode::F823,
                 CheckCode::F831,
                 CheckCode::F841,
+                CheckCode::F842,
                 CheckCode::F901,
             ],
             CheckCodePrefix::F4 => vec![
@@ -1108,20 +1178,25 @@ impl CheckCodePrefix {
             CheckCodePrefix::F72 => vec![CheckCode::F722],
             CheckCodePrefix::F722 => vec![CheckCode::F722],
             CheckCodePrefix::F8 => vec![
+                CheckCode::F811,
                 CheckCode::F821,
                 CheckCode::F822,
                 CheckCode::F823,
                 CheckCode::F831,
                 CheckCode::F841,
+                CheckCode::F842,
             ],
+            CheckCodePrefix::F81 => vec![CheckCode::F811],
+            CheckCodePrefix::F811 => vec![CheckCode::F811],
             CheckCodePrefix::F82 => vec![CheckCode::F821, CheckCode::F822, CheckCode::F823],
             CheckCodePrefix::F821 => vec![CheckCode::F821],
             CheckCodePrefix::F822 => vec![CheckCode::F822],
             CheckCodePrefix::F823 => vec![CheckCode::F823],
             CheckCodePrefix::F83 => vec![CheckCode::F831],
             CheckCodePrefix::F831 => vec![CheckCode::F831],
-            CheckCodePrefix::F84 => vec![CheckCode::F841],
+            CheckCodePrefix::F84 => vec![CheckCode::F841, CheckCode::F842],
             CheckCodePrefix::F841 => vec![CheckCode::F841],
+            CheckCodePrefix::F842 => vec![CheckCode::F842],
             CheckCodePrefix::F9 => vec![CheckCode::F901],
             CheckCodePrefix::F90 => vec![CheckCode::F901],
             CheckCodePrefix::F901 => vec![CheckCode::F901],
@@ -1131,13 +1206,68 @@ impl CheckCodePrefix {
             CheckCodePrefix::FBT001 => vec![CheckCode::FBT001],
             CheckCodePrefix::FBT002 => vec![CheckCode::FBT002],
             CheckCodePrefix::FBT003 => vec![CheckCode::FBT003],
-            CheckCodePrefix::I => vec![CheckCode::I252, CheckCode::I001],
+            CheckCodePrefix::I => vec![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::I2 => {
+                eprintln!(
+                    "{}{} {}",
+                    "warning".yellow().bold(),
+                    ":".bold(),
+                    "`I2` has been remapped to `TID2`".bold()
+                );
+                vec![CheckCode::TID252]
+            }
+            CheckCodePrefix::I25 => {
+                eprintln!(
+                    "{}{} {}",
+                    "warning".yellow().bold(),
+                    ":".bold(),
+                    "`I25` has been remapped to `TID25`".bold()
+                );
+                vec![CheckCode::TID252]
+            }
+            CheckCodePrefix::I252 => {
+                eprintln!(
+                    "{}{} {}",
+                    "warning".yellow().bold(),
+                    ":".bold(),
+                    "`I252` has been remapped to `TID252`".bold()
+                );
+                vec![CheckCode::TID252]
+            }
+            CheckCodePrefix::ICN => vec![CheckCode::ICN001],
+            CheckCodePrefix::ICN0 => vec![CheckCode::ICN001],
+            CheckCodePrefix::ICN00 => vec![CheckCode::ICN001],
+            CheckCodePrefix::ICN001 => vec![CheckCode::ICN001],
+            CheckCodePrefix::M => {
+                eprintln!(
+                    "{}{} {}",
+                    "warning".yellow().bold(),
+                    ":".bold(),
+                    "`M` has been remapped to `RUF100`".bold()
+                );
+                vec![CheckCode::RUF100]
+            }
+            CheckCodePrefix::M0 => {
+                eprintln!(
+                    "{}{} {}",
+                    "warning".yellow().bold(),
+                    ":".bold(),
+                    "`M0` has been remapped to `RUF100`".bold()
+                );
+                vec![CheckCode::RUF100]
+            }
+            CheckCodePrefix::M001 => {
+                eprintln!(
+                    "{}{} {}",
+                    "warning".yellow().bold(),
+                    ":".bold(),
+                    "`M001` has been remapped to `RUF100`".bold()
+                );
+                vec![CheckCode::RUF100]
+            }
             CheckCodePrefix::N => vec![
                 CheckCode::N801,
                 CheckCode::N802,
@@ -1225,7 +1355,14 @@ impl CheckCodePrefix {
             CheckCodePrefix::PLC30 => vec![CheckCode::PLC3002],
             CheckCodePrefix::PLC300 => vec![CheckCode::PLC3002],
             CheckCodePrefix::PLC3002 => vec![CheckCode::PLC3002],
-            CheckCodePrefix::PLE => vec![CheckCode::PLE1142],
+            CheckCodePrefix::PLE => {
+                vec![CheckCode::PLE0117, CheckCode::PLE0118, CheckCode::PLE1142]
+            }
+            CheckCodePrefix::PLE0 => vec![CheckCode::PLE0117, CheckCode::PLE0118],
+            CheckCodePrefix::PLE01 => vec![CheckCode::PLE0117, CheckCode::PLE0118],
+            CheckCodePrefix::PLE011 => vec![CheckCode::PLE0117, CheckCode::PLE0118],
+            CheckCodePrefix::PLE0117 => vec![CheckCode::PLE0117],
+            CheckCodePrefix::PLE0118 => vec![CheckCode::PLE0118],
             CheckCodePrefix::PLE1 => vec![CheckCode::PLE1142],
             CheckCodePrefix::PLE11 => vec![CheckCode::PLE1142],
             CheckCodePrefix::PLE114 => vec![CheckCode::PLE1142],
@@ -1249,11 +1386,14 @@ impl CheckCodePrefix {
             CheckCodePrefix::PLR1701 => vec![CheckCode::PLR1701],
             CheckCodePrefix::PLR172 => vec![CheckCode::PLR1722],
             CheckCodePrefix::PLR1722 => vec![CheckCode::PLR1722],
-            CheckCodePrefix::PLW => vec![CheckCode::PLW0120],
-            CheckCodePrefix::PLW0 => vec![CheckCode::PLW0120],
+            CheckCodePrefix::PLW => vec![CheckCode::PLW0120, CheckCode::PLW0602],
+            CheckCodePrefix::PLW0 => vec![CheckCode::PLW0120, CheckCode::PLW0602],
             CheckCodePrefix::PLW01 => vec![CheckCode::PLW0120],
             CheckCodePrefix::PLW012 => vec![CheckCode::PLW0120],
             CheckCodePrefix::PLW0120 => vec![CheckCode::PLW0120],
+            CheckCodePrefix::PLW06 => vec![CheckCode::PLW0602],
+            CheckCodePrefix::PLW060 => vec![CheckCode::PLW0602],
+            CheckCodePrefix::PLW0602 => vec![CheckCode::PLW0602],
             CheckCodePrefix::Q => vec![
                 CheckCode::Q000,
                 CheckCode::Q001,
@@ -1358,6 +1498,10 @@ impl CheckCodePrefix {
             CheckCodePrefix::S105 => vec![CheckCode::S105],
             CheckCodePrefix::S106 => vec![CheckCode::S106],
             CheckCodePrefix::S107 => vec![CheckCode::S107],
+            CheckCodePrefix::SIM => vec![CheckCode::SIM118],
+            CheckCodePrefix::SIM1 => vec![CheckCode::SIM118],
+            CheckCodePrefix::SIM11 => vec![CheckCode::SIM118],
+            CheckCodePrefix::SIM118 => vec![CheckCode::SIM118],
             CheckCodePrefix::T => vec![CheckCode::T100, CheckCode::T201, CheckCode::T203],
             CheckCodePrefix::T1 => vec![CheckCode::T100],
             CheckCodePrefix::T10 => vec![CheckCode::T100],
@@ -1366,54 +1510,82 @@ impl CheckCodePrefix {
             CheckCodePrefix::T20 => vec![CheckCode::T201, CheckCode::T203],
             CheckCodePrefix::T201 => vec![CheckCode::T201],
             CheckCodePrefix::T203 => vec![CheckCode::T203],
-            CheckCodePrefix::U => vec![
-                CheckCode::UP001,
-                CheckCode::UP003,
-                CheckCode::UP004,
-                CheckCode::UP005,
-                CheckCode::UP006,
-                CheckCode::UP007,
-                CheckCode::UP008,
-                CheckCode::UP009,
-                CheckCode::UP010,
-                CheckCode::UP011,
-                CheckCode::UP012,
-                CheckCode::UP013,
-                CheckCode::UP014,
-                CheckCode::UP015,
-            ],
-            CheckCodePrefix::U0 => vec![
-                CheckCode::UP001,
-                CheckCode::UP003,
-                CheckCode::UP004,
-                CheckCode::UP005,
-                CheckCode::UP006,
-                CheckCode::UP007,
-                CheckCode::UP008,
-                CheckCode::UP009,
-                CheckCode::UP010,
-                CheckCode::UP011,
-                CheckCode::UP012,
-                CheckCode::UP013,
-                CheckCode::UP014,
-                CheckCode::UP015,
-            ],
-            CheckCodePrefix::U00 => vec![
-                CheckCode::UP001,
-                CheckCode::UP003,
-                CheckCode::UP004,
-                CheckCode::UP005,
-                CheckCode::UP006,
-                CheckCode::UP007,
-                CheckCode::UP008,
-                CheckCode::UP009,
-            ],
+            CheckCodePrefix::TID => vec![CheckCode::TID252],
+            CheckCodePrefix::TID2 => vec![CheckCode::TID252],
+            CheckCodePrefix::TID25 => vec![CheckCode::TID252],
+            CheckCodePrefix::TID252 => vec![CheckCode::TID252],
+            CheckCodePrefix::U => {
+                eprintln!(
+                    "{}{} {}",
+                    "warning".yellow().bold(),
+                    ":".bold(),
+                    "`U` has been remapped to `UP`".bold()
+                );
+                vec![
+                    CheckCode::UP001,
+                    CheckCode::UP003,
+                    CheckCode::UP004,
+                    CheckCode::UP005,
+                    CheckCode::UP006,
+                    CheckCode::UP007,
+                    CheckCode::UP008,
+                    CheckCode::UP009,
+                    CheckCode::UP010,
+                    CheckCode::UP011,
+                    CheckCode::UP012,
+                    CheckCode::UP013,
+                    CheckCode::UP014,
+                    CheckCode::UP015,
+                ]
+            }
+            CheckCodePrefix::U0 => {
+                eprintln!(
+                    "{}{} {}",
+                    "warning".yellow().bold(),
+                    ":".bold(),
+                    "`U0` has been remapped to `UP0`".bold()
+                );
+                vec![
+                    CheckCode::UP001,
+                    CheckCode::UP003,
+                    CheckCode::UP004,
+                    CheckCode::UP005,
+                    CheckCode::UP006,
+                    CheckCode::UP007,
+                    CheckCode::UP008,
+                    CheckCode::UP009,
+                    CheckCode::UP010,
+                    CheckCode::UP011,
+                    CheckCode::UP012,
+                    CheckCode::UP013,
+                    CheckCode::UP014,
+                    CheckCode::UP015,
+                ]
+            }
+            CheckCodePrefix::U00 => {
+                eprintln!(
+                    "{}{} {}",
+                    "warning".yellow().bold(),
+                    ":".bold(),
+                    "`U00` has been remapped to `UP00`".bold()
+                );
+                vec![
+                    CheckCode::UP001,
+                    CheckCode::UP003,
+                    CheckCode::UP004,
+                    CheckCode::UP005,
+                    CheckCode::UP006,
+                    CheckCode::UP007,
+                    CheckCode::UP008,
+                    CheckCode::UP009,
+                ]
+            }
             CheckCodePrefix::U001 => {
                 eprintln!(
                     "{}{} {}",
                     "warning".yellow().bold(),
                     ":".bold(),
-                    "`U001` has been renamed to `UP001`".bold()
+                    "`U001` has been remapped to `UP001`".bold()
                 );
                 vec![CheckCode::UP001]
             }
@@ -1422,7 +1594,7 @@ impl CheckCodePrefix {
                     "{}{} {}",
                     "warning".yellow().bold(),
                     ":".bold(),
-                    "`U003` has been renamed to `UP003`".bold()
+                    "`U003` has been remapped to `UP003`".bold()
                 );
                 vec![CheckCode::UP003]
             }
@@ -1431,7 +1603,7 @@ impl CheckCodePrefix {
                     "{}{} {}",
                     "warning".yellow().bold(),
                     ":".bold(),
-                    "`U004` has been renamed to `UP004`".bold()
+                    "`U004` has been remapped to `UP004`".bold()
                 );
                 vec![CheckCode::UP004]
             }
@@ -1440,7 +1612,7 @@ impl CheckCodePrefix {
                     "{}{} {}",
                     "warning".yellow().bold(),
                     ":".bold(),
-                    "`U005` has been renamed to `UP005`".bold()
+                    "`U005` has been remapped to `UP005`".bold()
                 );
                 vec![CheckCode::UP005]
             }
@@ -1449,7 +1621,7 @@ impl CheckCodePrefix {
                     "{}{} {}",
                     "warning".yellow().bold(),
                     ":".bold(),
-                    "`U006` has been renamed to `UP006`".bold()
+                    "`U006` has been remapped to `UP006`".bold()
                 );
                 vec![CheckCode::UP006]
             }
@@ -1458,7 +1630,7 @@ impl CheckCodePrefix {
                     "{}{} {}",
                     "warning".yellow().bold(),
                     ":".bold(),
-                    "`U007` has been renamed to `UP007`".bold()
+                    "`U007` has been remapped to `UP007`".bold()
                 );
                 vec![CheckCode::UP007]
             }
@@ -1467,7 +1639,7 @@ impl CheckCodePrefix {
                     "{}{} {}",
                     "warning".yellow().bold(),
                     ":".bold(),
-                    "`U008` has been renamed to `UP008`".bold()
+                    "`U008` has been remapped to `UP008`".bold()
                 );
                 vec![CheckCode::UP008]
             }
@@ -1476,24 +1648,32 @@ impl CheckCodePrefix {
                     "{}{} {}",
                     "warning".yellow().bold(),
                     ":".bold(),
-                    "`U009` has been renamed to `UP009`".bold()
+                    "`U009` has been remapped to `UP009`".bold()
                 );
                 vec![CheckCode::UP009]
             }
-            CheckCodePrefix::U01 => vec![
-                CheckCode::UP010,
-                CheckCode::UP011,
-                CheckCode::UP012,
-                CheckCode::UP013,
-                CheckCode::UP014,
-                CheckCode::UP015,
-            ],
+            CheckCodePrefix::U01 => {
+                eprintln!(
+                    "{}{} {}",
+                    "warning".yellow().bold(),
+                    ":".bold(),
+                    "`U01` has been remapped to `UP01`".bold()
+                );
+                vec![
+                    CheckCode::UP010,
+                    CheckCode::UP011,
+                    CheckCode::UP012,
+                    CheckCode::UP013,
+                    CheckCode::UP014,
+                    CheckCode::UP015,
+                ]
+            }
             CheckCodePrefix::U010 => {
                 eprintln!(
                     "{}{} {}",
                     "warning".yellow().bold(),
                     ":".bold(),
-                    "`U010` has been renamed to `UP010`".bold()
+                    "`U010` has been remapped to `UP010`".bold()
                 );
                 vec![CheckCode::UP010]
             }
@@ -1502,7 +1682,7 @@ impl CheckCodePrefix {
                     "{}{} {}",
                     "warning".yellow().bold(),
                     ":".bold(),
-                    "`U011` has been renamed to `UP011`".bold()
+                    "`U011` has been remapped to `UP011`".bold()
                 );
                 vec![CheckCode::UP011]
             }
@@ -1511,7 +1691,7 @@ impl CheckCodePrefix {
                     "{}{} {}",
                     "warning".yellow().bold(),
                     ":".bold(),
-                    "`U012` has been renamed to `UP012`".bold()
+                    "`U012` has been remapped to `UP012`".bold()
                 );
                 vec![CheckCode::UP012]
             }
@@ -1520,7 +1700,7 @@ impl CheckCodePrefix {
                     "{}{} {}",
                     "warning".yellow().bold(),
                     ":".bold(),
-                    "`U013` has been renamed to `UP013`".bold()
+                    "`U013` has been remapped to `UP013`".bold()
                 );
                 vec![CheckCode::UP013]
             }
@@ -1529,7 +1709,7 @@ impl CheckCodePrefix {
                     "{}{} {}",
                     "warning".yellow().bold(),
                     ":".bold(),
-                    "`U014` has been renamed to `UP014`".bold()
+                    "`U014` has been remapped to `UP014`".bold()
                 );
                 vec![CheckCode::UP014]
             }
@@ -1538,7 +1718,7 @@ impl CheckCodePrefix {
                     "{}{} {}",
                     "warning".yellow().bold(),
                     ":".bold(),
-                    "`U015` has been renamed to `UP015`".bold()
+                    "`U015` has been remapped to `UP015`".bold()
                 );
                 vec![CheckCode::UP015]
             }
@@ -1685,6 +1865,14 @@ impl CheckCodePrefix {
             CheckCodePrefix::ANN4 => SuffixLength::One,
             CheckCodePrefix::ANN40 => SuffixLength::Two,
             CheckCodePrefix::ANN401 => SuffixLength::Three,
+            CheckCodePrefix::ARG => SuffixLength::Zero,
+            CheckCodePrefix::ARG0 => SuffixLength::One,
+            CheckCodePrefix::ARG00 => SuffixLength::Two,
+            CheckCodePrefix::ARG001 => SuffixLength::Three,
+            CheckCodePrefix::ARG002 => SuffixLength::Three,
+            CheckCodePrefix::ARG003 => SuffixLength::Three,
+            CheckCodePrefix::ARG004 => SuffixLength::Three,
+            CheckCodePrefix::ARG005 => SuffixLength::Three,
             CheckCodePrefix::B => SuffixLength::Zero,
             CheckCodePrefix::B0 => SuffixLength::One,
             CheckCodePrefix::B00 => SuffixLength::Two,
@@ -1719,6 +1907,7 @@ impl CheckCodePrefix {
             CheckCodePrefix::B9 => SuffixLength::One,
             CheckCodePrefix::B90 => SuffixLength::Two,
             CheckCodePrefix::B904 => SuffixLength::Three,
+            CheckCodePrefix::B905 => SuffixLength::Three,
             CheckCodePrefix::BLE => SuffixLength::Zero,
             CheckCodePrefix::BLE0 => SuffixLength::One,
             CheckCodePrefix::BLE00 => SuffixLength::Two,
@@ -1779,6 +1968,7 @@ impl CheckCodePrefix {
             CheckCodePrefix::D3 => SuffixLength::One,
             CheckCodePrefix::D30 => SuffixLength::Two,
             CheckCodePrefix::D300 => SuffixLength::Three,
+            CheckCodePrefix::D301 => SuffixLength::Three,
             CheckCodePrefix::D4 => SuffixLength::One,
             CheckCodePrefix::D40 => SuffixLength::Two,
             CheckCodePrefix::D400 => SuffixLength::Three,
@@ -1883,6 +2073,8 @@ impl CheckCodePrefix {
             CheckCodePrefix::F72 => SuffixLength::Two,
             CheckCodePrefix::F722 => SuffixLength::Three,
             CheckCodePrefix::F8 => SuffixLength::One,
+            CheckCodePrefix::F81 => SuffixLength::Two,
+            CheckCodePrefix::F811 => SuffixLength::Three,
             CheckCodePrefix::F82 => SuffixLength::Two,
             CheckCodePrefix::F821 => SuffixLength::Three,
             CheckCodePrefix::F822 => SuffixLength::Three,
@@ -1891,6 +2083,7 @@ impl CheckCodePrefix {
             CheckCodePrefix::F831 => SuffixLength::Three,
             CheckCodePrefix::F84 => SuffixLength::Two,
             CheckCodePrefix::F841 => SuffixLength::Three,
+            CheckCodePrefix::F842 => SuffixLength::Three,
             CheckCodePrefix::F9 => SuffixLength::One,
             CheckCodePrefix::F90 => SuffixLength::Two,
             CheckCodePrefix::F901 => SuffixLength::Three,
@@ -1907,6 +2100,13 @@ impl CheckCodePrefix {
             CheckCodePrefix::I2 => SuffixLength::One,
             CheckCodePrefix::I25 => SuffixLength::Two,
             CheckCodePrefix::I252 => SuffixLength::Three,
+            CheckCodePrefix::ICN => SuffixLength::Zero,
+            CheckCodePrefix::ICN0 => SuffixLength::One,
+            CheckCodePrefix::ICN00 => SuffixLength::Two,
+            CheckCodePrefix::ICN001 => SuffixLength::Three,
+            CheckCodePrefix::M => SuffixLength::Zero,
+            CheckCodePrefix::M0 => SuffixLength::One,
+            CheckCodePrefix::M001 => SuffixLength::Three,
             CheckCodePrefix::N => SuffixLength::Zero,
             CheckCodePrefix::N8 => SuffixLength::One,
             CheckCodePrefix::N80 => SuffixLength::Two,
@@ -1944,6 +2144,11 @@ impl CheckCodePrefix {
             CheckCodePrefix::PLC300 => SuffixLength::Three,
             CheckCodePrefix::PLC3002 => SuffixLength::Four,
             CheckCodePrefix::PLE => SuffixLength::Zero,
+            CheckCodePrefix::PLE0 => SuffixLength::One,
+            CheckCodePrefix::PLE01 => SuffixLength::Two,
+            CheckCodePrefix::PLE011 => SuffixLength::Three,
+            CheckCodePrefix::PLE0117 => SuffixLength::Four,
+            CheckCodePrefix::PLE0118 => SuffixLength::Four,
             CheckCodePrefix::PLE1 => SuffixLength::One,
             CheckCodePrefix::PLE11 => SuffixLength::Two,
             CheckCodePrefix::PLE114 => SuffixLength::Three,
@@ -1967,6 +2172,9 @@ impl CheckCodePrefix {
             CheckCodePrefix::PLW01 => SuffixLength::Two,
             CheckCodePrefix::PLW012 => SuffixLength::Three,
             CheckCodePrefix::PLW0120 => SuffixLength::Four,
+            CheckCodePrefix::PLW06 => SuffixLength::Two,
+            CheckCodePrefix::PLW060 => SuffixLength::Three,
+            CheckCodePrefix::PLW0602 => SuffixLength::Four,
             CheckCodePrefix::Q => SuffixLength::Zero,
             CheckCodePrefix::Q0 => SuffixLength::One,
             CheckCodePrefix::Q00 => SuffixLength::Two,
@@ -2003,6 +2211,10 @@ impl CheckCodePrefix {
             CheckCodePrefix::S105 => SuffixLength::Three,
             CheckCodePrefix::S106 => SuffixLength::Three,
             CheckCodePrefix::S107 => SuffixLength::Three,
+            CheckCodePrefix::SIM => SuffixLength::Zero,
+            CheckCodePrefix::SIM1 => SuffixLength::One,
+            CheckCodePrefix::SIM11 => SuffixLength::Two,
+            CheckCodePrefix::SIM118 => SuffixLength::Three,
             CheckCodePrefix::T => SuffixLength::Zero,
             CheckCodePrefix::T1 => SuffixLength::One,
             CheckCodePrefix::T10 => SuffixLength::Two,
@@ -2011,6 +2223,10 @@ impl CheckCodePrefix {
             CheckCodePrefix::T20 => SuffixLength::Two,
             CheckCodePrefix::T201 => SuffixLength::Three,
             CheckCodePrefix::T203 => SuffixLength::Three,
+            CheckCodePrefix::TID => SuffixLength::Zero,
+            CheckCodePrefix::TID2 => SuffixLength::One,
+            CheckCodePrefix::TID25 => SuffixLength::Two,
+            CheckCodePrefix::TID252 => SuffixLength::Three,
             CheckCodePrefix::U => SuffixLength::Zero,
             CheckCodePrefix::U0 => SuffixLength::One,
             CheckCodePrefix::U00 => SuffixLength::Two,
@@ -2078,6 +2294,7 @@ impl CheckCodePrefix {
 pub const CATEGORIES: &[CheckCodePrefix] = &[
     CheckCodePrefix::A,
     CheckCodePrefix::ANN,
+    CheckCodePrefix::ARG,
     CheckCodePrefix::B,
     CheckCodePrefix::BLE,
     CheckCodePrefix::C,
@@ -2087,6 +2304,7 @@ pub const CATEGORIES: &[CheckCodePrefix] = &[
     CheckCodePrefix::F,
     CheckCodePrefix::FBT,
     CheckCodePrefix::I,
+    CheckCodePrefix::ICN,
     CheckCodePrefix::N,
     CheckCodePrefix::PGH,
     CheckCodePrefix::PLC,
@@ -2097,8 +2315,9 @@ pub const CATEGORIES: &[CheckCodePrefix] = &[
     CheckCodePrefix::RET,
     CheckCodePrefix::RUF,
     CheckCodePrefix::S,
+    CheckCodePrefix::SIM,
     CheckCodePrefix::T,
-    CheckCodePrefix::U,
+    CheckCodePrefix::TID,
     CheckCodePrefix::UP,
     CheckCodePrefix::W,
     CheckCodePrefix::YTT,

src/cli.rs

@@ -47,42 +47,44 @@ pub struct Cli {
     pub no_cache: bool,
     /// List of error codes to enable.
     #[arg(long, value_delimiter = ',')]
-    pub select: Vec<CheckCodePrefix>,
+    pub select: Option<Vec<CheckCodePrefix>>,
     /// Like --select, but adds additional error codes on top of the selected
     /// ones.
     #[arg(long, value_delimiter = ',')]
-    pub extend_select: Vec<CheckCodePrefix>,
+    pub extend_select: Option<Vec<CheckCodePrefix>>,
     /// List of error codes to ignore.
     #[arg(long, value_delimiter = ',')]
-    pub ignore: Vec<CheckCodePrefix>,
+    pub ignore: Option<Vec<CheckCodePrefix>>,
     /// Like --ignore, but adds additional error codes on top of the ignored
     /// ones.
     #[arg(long, value_delimiter = ',')]
-    pub extend_ignore: Vec<CheckCodePrefix>,
+    pub extend_ignore: Option<Vec<CheckCodePrefix>>,
     /// List of paths, used to exclude files and/or directories from checks.
     #[arg(long, value_delimiter = ',')]
-    pub exclude: Vec<FilePattern>,
+    pub exclude: Option<Vec<FilePattern>>,
     /// Like --exclude, but adds additional files and directories on top of the
     /// excluded ones.
     #[arg(long, value_delimiter = ',')]
-    pub extend_exclude: Vec<FilePattern>,
+    pub extend_exclude: Option<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>,
+    pub fixable: Option<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>,
+    pub unfixable: Option<Vec<CheckCodePrefix>>,
     /// List of mappings from file pattern to code to exclude
     #[arg(long, value_delimiter = ',')]
-    pub per_file_ignores: Vec<PatternPrefixPair>,
+    pub per_file_ignores: Option<Vec<PatternPrefixPair>>,
     /// Output serialization format for error messages.
     #[arg(long, value_enum)]
     pub format: Option<SerializationFormat>,
     /// Show violations with source code.
-    #[arg(long)]
-    pub show_source: bool,
+    #[arg(long, overrides_with("no_show_source"))]
+    show_source: bool,
+    #[clap(long, overrides_with("show_source"), hide = true)]
+    no_show_source: bool,
     /// See the files Ruff will be run against with the current settings.
     #[arg(long)]
     pub show_files: bool,
@@ -121,9 +123,47 @@ pub struct Cli {
 }
 
 impl Cli {
-    // See: https://github.com/clap-rs/clap/issues/3146
-    pub fn fix(&self) -> Option<bool> {
-        resolve_bool_arg(self.fix, self.no_fix)
+    /// Partition the CLI into command-line arguments and configuration
+    /// overrides.
+    pub fn partition(self) -> (Arguments, Overrides) {
+        (
+            Arguments {
+                add_noqa: self.add_noqa,
+                autoformat: self.autoformat,
+                config: self.config,
+                exit_zero: self.exit_zero,
+                explain: self.explain,
+                files: self.files,
+                generate_shell_completion: self.generate_shell_completion,
+                no_cache: self.no_cache,
+                quiet: self.quiet,
+                show_files: self.show_files,
+                show_settings: self.show_settings,
+                silent: self.silent,
+                stdin_filename: self.stdin_filename,
+                verbose: self.verbose,
+                watch: self.watch,
+            },
+            Overrides {
+                dummy_variable_rgx: self.dummy_variable_rgx,
+                exclude: self.exclude,
+                extend_exclude: self.extend_exclude,
+                extend_ignore: self.extend_ignore,
+                extend_select: self.extend_select,
+                fixable: self.fixable,
+                ignore: self.ignore,
+                line_length: self.line_length,
+                max_complexity: self.max_complexity,
+                per_file_ignores: self.per_file_ignores,
+                select: self.select,
+                show_source: resolve_bool_arg(self.show_source, self.no_show_source),
+                target_version: self.target_version,
+                unfixable: self.unfixable,
+                // TODO(charlie): Included in `pyproject.toml`, but not inherited.
+                fix: resolve_bool_arg(self.fix, self.no_fix),
+                format: self.format,
+            },
+        )
     }
 }
 
@@ -136,8 +176,51 @@ fn resolve_bool_arg(yes: bool, no: bool) -> Option<bool> {
     }
 }
 
+/// CLI settings that are distinct from configuration (commands, lists of files,
+/// etc.).
+#[allow(clippy::struct_excessive_bools)]
+pub struct Arguments {
+    pub add_noqa: bool,
+    pub autoformat: bool,
+    pub config: Option<PathBuf>,
+    pub exit_zero: bool,
+    pub explain: Option<CheckCode>,
+    pub files: Vec<PathBuf>,
+    pub generate_shell_completion: Option<clap_complete_command::Shell>,
+    pub no_cache: bool,
+    pub quiet: bool,
+    pub show_files: bool,
+    pub show_settings: bool,
+    pub silent: bool,
+    pub stdin_filename: Option<String>,
+    pub verbose: bool,
+    pub watch: bool,
+}
+
+/// CLI settings that function as configuration overrides.
+#[allow(clippy::struct_excessive_bools)]
+pub struct Overrides {
+    pub dummy_variable_rgx: Option<Regex>,
+    pub exclude: Option<Vec<FilePattern>>,
+    pub extend_exclude: Option<Vec<FilePattern>>,
+    pub extend_ignore: Option<Vec<CheckCodePrefix>>,
+    pub extend_select: Option<Vec<CheckCodePrefix>>,
+    pub fixable: Option<Vec<CheckCodePrefix>>,
+    pub ignore: Option<Vec<CheckCodePrefix>>,
+    pub line_length: Option<usize>,
+    pub max_complexity: Option<usize>,
+    pub per_file_ignores: Option<Vec<PatternPrefixPair>>,
+    pub select: Option<Vec<CheckCodePrefix>>,
+    pub show_source: Option<bool>,
+    pub target_version: Option<PythonVersion>,
+    pub unfixable: Option<Vec<CheckCodePrefix>>,
+    // TODO(charlie): Captured in pyproject.toml as a default, but not part of `Settings`.
+    pub fix: Option<bool>,
+    pub format: Option<SerializationFormat>,
+}
+
 /// Map the CLI settings to a `LogLevel`.
-pub fn extract_log_level(cli: &Cli) -> LogLevel {
+pub fn extract_log_level(cli: &Arguments) -> LogLevel {
     if cli.silent {
         LogLevel::Silent
     } else if cli.quiet {

src/directives.rs

@@ -93,32 +93,34 @@ pub fn extract_isort_directives(lxr: &[LexResult], locator: &SourceCodeLocator)
             continue;
         }
 
-        if matches!(tok, Tok::Comment) {
-            // TODO(charlie): Modify RustPython to include the comment text in the token.
-            let comment_text = locator.slice_source_code_range(&Range {
-                location: start,
-                end_location: end,
-            });
+        if !matches!(tok, Tok::Comment) {
+            continue;
+        }
 
-            if comment_text == "# isort: split" {
-                splits.push(start.row());
-            } else if comment_text == "# isort: skip_file" {
-                skip_file = true;
-            } else if off.is_some() {
-                if comment_text == "# isort: on" {
-                    if let Some(start) = off {
-                        for row in start.row() + 1..=end.row() {
-                            exclusions.insert(row);
-                        }
+        // TODO(charlie): Modify RustPython to include the comment text in the token.
+        let comment_text = locator.slice_source_code_range(&Range {
+            location: start,
+            end_location: end,
+        });
+
+        if comment_text == "# isort: split" {
+            splits.push(start.row());
+        } else if comment_text == "# isort: skip_file" {
+            skip_file = true;
+        } else if off.is_some() {
+            if comment_text == "# isort: on" {
+                if let Some(start) = off {
+                    for row in start.row() + 1..=end.row() {
+                        exclusions.insert(row);
                     }
-                    off = None;
-                }
-            } else {
-                if comment_text.contains("isort: skip") {
-                    exclusions.insert(start.row());
-                } else if comment_text == "# isort: off" {
-                    off = Some(start);
                 }
+                off = None;
+            }
+        } else {
+            if comment_text.contains("isort: skip") {
+                exclusions.insert(start.row());
+            } else if comment_text == "# isort: off" {
+                off = Some(start);
             }
         }
     }

src/docstrings/constants.rs

@@ -1,5 +1,9 @@
 pub const TRIPLE_QUOTE_PREFIXES: &[&str] = &[
-    "ur\"\"\"", "ur'''", "u\"\"\"", "u'''", "r\"\"\"", "r'''", "\"\"\"", "'''",
+    "ur\"\"\"", "ur'''", "u\"\"\"", "u'''", "r\"\"\"", "r'''", "UR\"\"\"", "UR'''", "Ur\"\"\"",
+    "Ur'''", "U\"\"\"", "U'''", "uR\"\"\"", "uR'''", "R\"\"\"", "R'''", "\"\"\"", "'''",
 ];
 
-pub const SINGLE_QUOTE_PREFIXES: &[&str] = &["ur\"", "ur'", "u\"", "u'", "r\"", "r'", "\"", "'"];
+pub const SINGLE_QUOTE_PREFIXES: &[&str] = &[
+    "ur\"", "ur'", "u\"", "u'", "r\"", "r'", "ur\"", "ur'", "u\"", "u'", "r\"", "r'", "UR\"",
+    "UR'", "Ur\"", "Ur'", "U\"", "U'", "uR\"", "uR'", "R\"", "R'", "\"", "'",
+];

src/docstrings/definition.rs

@@ -1,6 +1,8 @@
+use std::borrow::Cow;
+
 use rustpython_ast::{Expr, Stmt};
 
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub enum DefinitionKind<'a> {
     Module,
     Package,
@@ -17,6 +19,15 @@ pub struct Definition<'a> {
     pub docstring: Option<&'a Expr>,
 }
 
+#[derive(Debug)]
+pub struct Docstring<'a> {
+    pub kind: DefinitionKind<'a>,
+    pub expr: &'a Expr,
+    pub contents: &'a Cow<'a, str>,
+    pub body: &'a str,
+    pub indentation: &'a Cow<'a, str>,
+}
+
 pub enum Documentable {
     Class,
     Function,

src/docstrings/sections.rs

@@ -3,7 +3,7 @@ use crate::docstrings::styles::SectionStyle;
 
 #[derive(Debug)]
 pub(crate) struct SectionContext<'a> {
-    pub(crate) section_name: String,
+    pub(crate) section_name: &'a str,
     pub(crate) previous_line: &'a str,
     pub(crate) line: &'a str,
     pub(crate) following_lines: &'a [&'a str],
@@ -22,7 +22,7 @@ fn is_docstring_section(context: &SectionContext) -> bool {
     let section_name_suffix = context
         .line
         .trim()
-        .strip_prefix(&context.section_name)
+        .strip_prefix(context.section_name)
         .unwrap()
         .trim();
     let this_looks_like_a_section_name =

src/eradicate/detection.rs

@@ -4,7 +4,7 @@ use regex::Regex;
 
 static ALLOWLIST_REGEX: Lazy<Regex> = Lazy::new(|| {
     Regex::new(
-        r"(?i)pylint|pyright|noqa|nosec|type:\s*ignore|fmt:\s*(on|off)|isort:\s*(on|off|skip|skip_file|split|dont-add-imports(:\s*\[.*?])?)|TODO|FIXME|XXX"
+        r"^(?i)(?:pylint|pyright|noqa|nosec|type:\s*ignore|fmt:\s*(on|off)|isort:\s*(on|off|skip|skip_file|split|dont-add-imports(:\s*\[.*?])?)|TODO|FIXME|XXX)"
     ).unwrap()
 });
 static BRACKET_REGEX: Lazy<Regex> = Lazy::new(|| Regex::new(r"^[()\[\]{}\s]+$").unwrap());

src/flake8_annotations/helpers.rs

@@ -0,0 +1,63 @@
+use rustpython_ast::{Arguments, Expr, Stmt, StmtKind};
+
+use crate::ast::cast;
+use crate::check_ast::Checker;
+use crate::docstrings::definition::{Definition, DefinitionKind};
+use crate::visibility;
+
+pub(super) fn match_function_def(
+    stmt: &Stmt,
+) -> (&str, &Arguments, &Option<Box<Expr>>, &Vec<Stmt>) {
+    match &stmt.node {
+        StmtKind::FunctionDef {
+            name,
+            args,
+            returns,
+            body,
+            ..
+        }
+        | StmtKind::AsyncFunctionDef {
+            name,
+            args,
+            returns,
+            body,
+            ..
+        } => (name, args, returns, body),
+        _ => panic!("Found non-FunctionDef in match_name"),
+    }
+}
+
+/// Return the name of the function, if it's overloaded.
+pub fn overloaded_name(checker: &Checker, definition: &Definition) -> Option<String> {
+    if let DefinitionKind::Function(stmt)
+    | DefinitionKind::NestedFunction(stmt)
+    | DefinitionKind::Method(stmt) = definition.kind
+    {
+        if visibility::is_overload(checker, cast::decorator_list(stmt)) {
+            let (name, ..) = match_function_def(stmt);
+            Some(name.to_string())
+        } else {
+            None
+        }
+    } else {
+        None
+    }
+}
+
+/// Return `true` if the definition is the implementation for an overloaded
+/// function.
+pub fn is_overload_impl(checker: &Checker, definition: &Definition, overloaded_name: &str) -> bool {
+    if let DefinitionKind::Function(stmt)
+    | DefinitionKind::NestedFunction(stmt)
+    | DefinitionKind::Method(stmt) = definition.kind
+    {
+        if visibility::is_overload(checker, cast::decorator_list(stmt)) {
+            false
+        } else {
+            let (name, ..) = match_function_def(stmt);
+            name == overloaded_name
+        }
+    } else {
+        false
+    }
+}

src/flake8_annotations/mod.rs

@@ -1,3 +1,4 @@
+pub mod helpers;
 pub mod plugins;
 pub mod settings;
 
@@ -134,4 +135,24 @@ mod tests {
         insta::assert_yaml_snapshot!(checks);
         Ok(())
     }
+
+    #[test]
+    fn allow_overload() -> Result<()> {
+        let mut checks = test_path(
+            Path::new("./resources/test/fixtures/flake8_annotations/allow_overload.py"),
+            &Settings {
+                ..Settings::for_rules(vec![
+                    CheckCode::ANN201,
+                    CheckCode::ANN202,
+                    CheckCode::ANN204,
+                    CheckCode::ANN205,
+                    CheckCode::ANN206,
+                ])
+            },
+            true,
+        )?;
+        checks.sort_by_key(|check| check.location);
+        insta::assert_yaml_snapshot!(checks);
+        Ok(())
+    }
 }

src/flake8_annotations/plugins.rs

@@ -1,11 +1,12 @@
-use rustpython_ast::{Arguments, Constant, Expr, ExprKind, Stmt, StmtKind};
+use rustpython_ast::{Constant, Expr, ExprKind, Stmt, StmtKind};
 
 use crate::ast::types::Range;
-use crate::ast::visitor;
 use crate::ast::visitor::Visitor;
+use crate::ast::{cast, visitor};
 use crate::check_ast::Checker;
 use crate::checks::{CheckCode, CheckKind};
 use crate::docstrings::definition::{Definition, DefinitionKind};
+use crate::flake8_annotations::helpers::match_function_def;
 use crate::visibility::Visibility;
 use crate::{visibility, Check};
 
@@ -61,26 +62,6 @@ where
     };
 }
 
-fn match_function_def(stmt: &Stmt) -> (&str, &Arguments, &Option<Box<Expr>>, &Vec<Stmt>) {
-    match &stmt.node {
-        StmtKind::FunctionDef {
-            name,
-            args,
-            returns,
-            body,
-            ..
-        }
-        | StmtKind::AsyncFunctionDef {
-            name,
-            args,
-            returns,
-            body,
-            ..
-        } => (name, args, returns, body),
-        _ => panic!("Found non-FunctionDef in match_name"),
-    }
-}
-
 /// Generate flake8-annotation checks for a given `Definition`.
 pub fn definition(checker: &mut Checker, definition: &Definition, visibility: &Visibility) {
     // TODO(charlie): Consider using the AST directly here rather than `Definition`.
@@ -211,7 +192,10 @@ pub fn definition(checker: &mut Checker, definition: &Definition, visibility: &V
                 .chain(args.kwonlyargs.iter())
                 .skip(
                     // If this is a non-static method, skip `cls` or `self`.
-                    usize::from(!visibility::is_staticmethod(checker, stmt)),
+                    usize::from(!visibility::is_staticmethod(
+                        checker,
+                        cast::decorator_list(stmt),
+                    )),
                 )
             {
                 // ANN401 for dynamically typed arguments
@@ -283,10 +267,10 @@ pub fn definition(checker: &mut Checker, definition: &Definition, visibility: &V
             }
 
             // ANN101, ANN102
-            if !visibility::is_staticmethod(checker, stmt) {
+            if !visibility::is_staticmethod(checker, cast::decorator_list(stmt)) {
                 if let Some(arg) = args.args.first() {
                     if arg.node.annotation.is_none() {
-                        if visibility::is_classmethod(checker, stmt) {
+                        if visibility::is_classmethod(checker, cast::decorator_list(stmt)) {
                             if checker.settings.enabled.contains(&CheckCode::ANN102) {
                                 checker.add_check(Check::new(
                                     CheckKind::MissingTypeCls(arg.node.arg.to_string()),
@@ -319,14 +303,14 @@ pub fn definition(checker: &mut Checker, definition: &Definition, visibility: &V
                     return;
                 }
 
-                if visibility::is_classmethod(checker, stmt) {
+                if visibility::is_classmethod(checker, cast::decorator_list(stmt)) {
                     if checker.settings.enabled.contains(&CheckCode::ANN206) {
                         checker.add_check(Check::new(
                             CheckKind::MissingReturnTypeClassMethod(name.to_string()),
                             Range::from_located(stmt),
                         ));
                     }
-                } else if visibility::is_staticmethod(checker, stmt) {
+                } else if visibility::is_staticmethod(checker, cast::decorator_list(stmt)) {
                     if checker.settings.enabled.contains(&CheckCode::ANN205) {
                         checker.add_check(Check::new(
                             CheckKind::MissingReturnTypeStaticMethod(name.to_string()),

src/flake8_annotations/settings.rs

@@ -1,22 +1,51 @@
 //! Settings for the `flake-annotations` plugin.
 
+use ruff_macros::ConfigurationOptions;
 use serde::{Deserialize, Serialize};
 
-#[derive(Debug, PartialEq, Eq, Serialize, Deserialize, Default)]
+#[derive(Debug, PartialEq, Eq, Serialize, Deserialize, Default, ConfigurationOptions)]
 #[serde(deny_unknown_fields, rename_all = "kebab-case")]
 pub struct Options {
-    /// Allow omission of a return type hint for `__init__` if at least one
-    /// argument is annotated.
+    #[option(
+        doc = r#"
+            Whether to allow the omission of a return type hint for `__init__` if at least one
+            argument is annotated.
+        "#,
+        default = "false",
+        value_type = "bool",
+        example = "mypy-init-return = true"
+    )]
     pub mypy_init_return: Option<bool>,
-    /// Suppress ANN000-level errors for dummy arguments, like `_`.
+    #[option(
+        doc = r#"
+            Whether to suppress `ANN000`-level errors for arguments matching the "dummy" variable
+            regex (like `_`).
+        "#,
+        default = "false",
+        value_type = "bool",
+        example = "suppress-dummy-args = true"
+    )]
     pub suppress_dummy_args: Option<bool>,
-    /// Suppress ANN200-level errors for functions that meet one of the
-    /// following criteria:
-    /// - Contain no `return` statement
-    /// - Explicit `return` statement(s) all return `None` (explicitly or
-    ///   implicitly).
+    #[option(
+        doc = r#"
+            Whether to suppress `ANN200`-level errors for functions that meet either of the
+            following criteria:
+
+            - Contain no `return` statement.
+            - Explicit `return` statement(s) all return `None` (explicitly or implicitly).
+        "#,
+        default = "false",
+        value_type = "bool",
+        example = "suppress-none-returning = true"
+    )]
     pub suppress_none_returning: Option<bool>,
-    /// Suppress ANN401 for dynamically typed *args and **kwargs.
+    #[option(
+        doc = "Whether to suppress `ANN401` for dynamically typed `*args` and `**kwargs` \
+               arguments.",
+        default = "false",
+        value_type = "bool",
+        example = "allow-star-arg-any = true"
+    )]
     pub allow_star_arg_any: Option<bool>,
 }
 

src/flake8_annotations/snapshots/ruff__flake8_annotations__tests__allow_overload.snap

@@ -0,0 +1,14 @@
+---
+source: src/flake8_annotations/mod.rs
+expression: checks
+---
+- kind:
+    MissingReturnTypePublicFunction: bar
+  location:
+    row: 29
+    column: 4
+  end_location:
+    row: 35
+    column: 0
+  fix: ~
+

src/flake8_blind_except/plugins.rs

@@ -1,21 +1,42 @@
-use rustpython_ast::{Excepthandler, ExcepthandlerKind, ExprKind};
+use rustpython_ast::{Expr, ExprKind, Stmt, StmtKind};
 
 use crate::ast::types::Range;
 use crate::check_ast::Checker;
 use crate::checks::{Check, CheckKind};
 
-pub fn blind_except(checker: &mut Checker, handlers: &[Excepthandler]) {
-    for handler in handlers {
-        let ExcepthandlerKind::ExceptHandler { type_: Some(type_), .. } = &handler.node else {
-            continue;
-        };
-        let ExprKind::Name { id, .. } = &type_.node else {
-            continue;
-        };
-        for exception in ["BaseException", "Exception"] {
-            if id == exception {
+/// BLE001
+pub fn blind_except(
+    checker: &mut Checker,
+    type_: Option<&Expr>,
+    name: Option<&str>,
+    body: &[Stmt],
+) {
+    let Some(type_) = type_ else {
+        return;
+    };
+    let ExprKind::Name { id, .. } = &type_.node else {
+        return;
+    };
+    for exception in ["BaseException", "Exception"] {
+        if id == exception && checker.is_builtin(exception) {
+            // If the exception is re-raised, don't flag an error.
+            if !body.iter().any(|stmt| {
+                if let StmtKind::Raise { exc, .. } = &stmt.node {
+                    if let Some(exc) = exc {
+                        if let ExprKind::Name { id, .. } = &exc.node {
+                            name.map_or(false, |name| name == id)
+                        } else {
+                            false
+                        }
+                    } else {
+                        true
+                    }
+                } else {
+                    false
+                }
+            }) {
                 checker.add_check(Check::new(
-                    CheckKind::BlindExcept,
+                    CheckKind::BlindExcept(id.to_string()),
                     Range::from_located(type_),
                 ));
             }

src/flake8_blind_except/snapshots/ruff__flake8_blind_except__tests__BLE001_BLE.py.snap

@@ -2,31 +2,8 @@
 source: src/flake8_blind_except/mod.rs
 expression: checks
 ---
-- kind: BlindExcept
-  location:
-    row: 5
-    column: 7
-  end_location:
-    row: 5
-    column: 16
-  fix: ~
-- kind: BlindExcept
-  location:
-    row: 13
-    column: 7
-  end_location:
-    row: 13
-    column: 20
-  fix: ~
-- kind: BlindExcept
-  location:
-    row: 23
-    column: 7
-  end_location:
-    row: 23
-    column: 16
-  fix: ~
-- kind: BlindExcept
+- kind:
+    BlindExcept: BaseException
   location:
     row: 25
     column: 7
@@ -34,7 +11,8 @@ expression: checks
     row: 25
     column: 20
   fix: ~
-- kind: BlindExcept
+- kind:
+    BlindExcept: Exception
   location:
     row: 31
     column: 7
@@ -42,15 +20,8 @@ expression: checks
     row: 31
     column: 16
   fix: ~
-- kind: BlindExcept
-  location:
-    row: 36
-    column: 11
-  end_location:
-    row: 36
-    column: 24
-  fix: ~
-- kind: BlindExcept
+- kind:
+    BlindExcept: Exception
   location:
     row: 42
     column: 7
@@ -58,7 +29,8 @@ expression: checks
     row: 42
     column: 16
   fix: ~
-- kind: BlindExcept
+- kind:
+    BlindExcept: BaseException
   location:
     row: 45
     column: 11
@@ -66,15 +38,8 @@ expression: checks
     row: 45
     column: 24
   fix: ~
-- kind: BlindExcept
-  location:
-    row: 52
-    column: 11
-  end_location:
-    row: 52
-    column: 24
-  fix: ~
-- kind: BlindExcept
+- kind:
+    BlindExcept: Exception
   location:
     row: 54
     column: 7
@@ -82,4 +47,22 @@ expression: checks
     row: 54
     column: 16
   fix: ~
+- kind:
+    BlindExcept: Exception
+  location:
+    row: 60
+    column: 7
+  end_location:
+    row: 60
+    column: 16
+  fix: ~
+- kind:
+    BlindExcept: BaseException
+  location:
+    row: 62
+    column: 7
+  end_location:
+    row: 62
+    column: 20
+  fix: ~
 

src/flake8_bugbear/mod.rs

@@ -39,6 +39,7 @@ mod tests {
     #[test_case(CheckCode::B026, Path::new("B026.py"); "B026")]
     #[test_case(CheckCode::B027, Path::new("B027.py"); "B027")]
     #[test_case(CheckCode::B904, Path::new("B904.py"); "B904")]
+    #[test_case(CheckCode::B905, Path::new("B905.py"); "B905")]
     fn checks(check_code: CheckCode, path: &Path) -> Result<()> {
         let snapshot = format!("{}_{}", check_code.as_ref(), path.to_string_lossy());
         let mut checks = test_path(