Bump version to 0.0.176

Check for outdated auto-generated files in CI (#1192 )
Add flake8-simplify to flake8-to-ruff
2022-12-11 10:19:50 -05:00 · 2022-12-11 10:18:57 -05:00 · 2022-12-11 10:10:46 -05:00 · 2022-12-11 10:05:32 -05:00 · 2022-12-11 10:05:11 -05:00 · 2022-12-11 10:04:06 -05:00
172 changed files with 8832 additions and 1897 deletions
--- a/.github/workflows/ci.yaml
+++ b/.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"
--- a/.github/workflows/ruff.yaml
+++ b/.github/workflows/ruff.yaml
@@ -1,9 +1,8 @@
 name: "[ruff] Release"

 on:
-  create:
-    tags:
-      - v*
+  release:
+    types: [published]

 concurrency:
  group: ${{ github.workflow }}-${{ github.ref }}
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -1,6 +1,6 @@
 repos:
  - repo: https://github.com/charliermarsh/ruff-pre-commit
-    rev: v0.0.167
+    rev: v0.0.176
    hooks:
      - id: ruff

--- a/Cargo.lock
+++ b/Cargo.lock
@@ -724,7 +724,7 @@ checksum = "0ce7134b9999ecaf8bcd65542e436736ef32ddca1b3e06094cb6ec5755203b80"

 [[package]]
 name = "flake8-to-ruff"
-version = "0.0.167-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.167"
+version = "0.0.176"
 dependencies = [
 "annotate-snippets 0.9.1",
 "anyhow",
@@ -1874,7 +1874,7 @@ dependencies = [

 [[package]]
 name = "ruff_dev"
-version = "0.0.167"
+version = "0.0.176"
 dependencies = [
 "anyhow",
 "clap 4.0.29",
@@ -1892,7 +1892,7 @@ dependencies = [

 [[package]]
 name = "ruff_macros"
-version = "0.0.161"
+version = "0.0.176"
 dependencies = [
 "proc-macro2",
 "quote",
@@ -1935,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",
@@ -1945,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",
@@ -1968,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",
@@ -1985,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",
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -6,7 +6,7 @@ members = [

 [package]
 name = "ruff"
-version = "0.0.167"
+version = "0.0.176"
 edition = "2021"
 rust-version = "1.65.0"

@@ -41,11 +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.161", path = "ruff_macros" }
+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"] }
--- a/75
+++ b/75
@@ -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)
--- a/README.md
+++ b/README.md
@@ -41,6 +41,7 @@ Ruff is extremely actively developed and used in major open-source projects like
 - [Pydantic](https://github.com/pydantic/pydantic)
 - [Saleor](https://github.com/saleor/saleor)
 - [Hatch](https://github.com/pypa/hatch)
+- [Jupyter Server](https://github.com/jupyter-server/jupyter_server)

 Read the [launch blog post](https://notes.crmarsh.com/python-tooling-could-be-much-much-faster).

@@ -72,7 +73,7 @@ of [Conda](https://docs.conda.io/en/latest/):
   1. [Pyflakes (F)](#pyflakes-f)
   1. [pycodestyle (E, W)](#pycodestyle-e-w)
   1. [mccabe (C90)](#mccabe-c90)
-   1. [isort (I00)](#isort-i00)
+   1. [isort (I)](#isort-i)
   1. [pydocstyle (D)](#pydocstyle-d)
   1. [pyupgrade (UP)](#pyupgrade-up)
   1. [pep8-naming (N)](#pep8-naming-n)
@@ -89,7 +90,9 @@ of [Conda](https://docs.conda.io/en/latest/):
   1. [flake8-print (T20)](#flake8-print-t20)
   1. [flake8-quotes (Q)](#flake8-quotes-q)
   1. [flake8-return (RET)](#flake8-return-ret)
-   1. [flake8-tidy-imports (I25)](#flake8-tidy-imports-i25)
+   1. [flake8-simplify (SIM)](#flake8-simplify-sim)
+   1. [flake8-tidy-imports (TID)](#flake8-tidy-imports-tid)
+   1. [flake8-unused-arguments (ARG)](#flake8-unused-arguments-arg)
   1. [eradicate (ERA)](#eradicate-era)
   1. [pygrep-hooks (PGH)](#pygrep-hooks-pgh)
   1. [Pylint (PLC, PLE, PLR, PLW)](#pylint-plc-ple-plr-plw)
@@ -119,12 +122,18 @@ For **macOS Homebrew** and **Linuxbrew** users, Ruff is also available as [`ruff
 brew install ruff
 ```

-For Conda users, Ruff is also available as [`ruff`](https://anaconda.org/conda-forge/ruff) on `conda-forge`:
+For **Conda** users, Ruff is also available as [`ruff`](https://anaconda.org/conda-forge/ruff) on `conda-forge`:

 ```shell
 conda install -c conda-forge ruff
 ```

+For **Arch Linux** users, Ruff is also available as [`ruff`](https://archlinux.org/packages/community/x86_64/ruff/) on the official repositories:
+
+```shell
+pacman -S ruff
+```
+
 ### Usage

 To run Ruff, try any of the following:
@@ -146,7 +155,7 @@ Ruff also works with [pre-commit](https://pre-commit.com):
 ```yaml
 repos:
  - repo: https://github.com/charliermarsh/ruff-pre-commit
-    rev: v0.0.167
+    rev: v0.0.176
    hooks:
      - id: ruff
 ```
@@ -361,7 +370,7 @@ For targeted exclusions across entire files (e.g., "Ignore all F841 violations i
 ### "Action Comments"

 Ruff respects `isort`'s ["Action Comments"](https://pycqa.github.io/isort/docs/configuration/action_comments.html)
-(`# isort: skip_file`, `# isort: on`, `# isort: off`, `# isort: skip`, and `isort: split`), which
+(`# isort: skip_file`, `# isort: on`, `# isort: off`, `# isort: skip`, and `# isort: split`), which
 enable selectively enabling and disabling import sorting for blocks of code and other inline
 configuration.

@@ -411,14 +420,14 @@ For more, see [Pyflakes](https://pypi.org/project/pyflakes/2.5.0/) on PyPI.
 | F501 | PercentFormatInvalidFormat | '...' % ... has invalid format string: ... |  |
 | F502 | PercentFormatExpectedMapping | '...' % ... expected mapping but got sequence |  |
 | F503 | PercentFormatExpectedSequence | '...' % ... expected sequence but got mapping |  |
-| F504 | PercentFormatExtraNamedArguments | '...' % ... has unused named argument(s): ... |  |
+| F504 | PercentFormatExtraNamedArguments | '...' % ... has unused named argument(s): ... | 🛠 |
 | F505 | PercentFormatMissingArgument | '...' % ... is missing argument(s) for placeholder(s): ... |  |
 | F506 | PercentFormatMixedPositionalAndNamed | '...' % ... has mixed positional and named placeholders |  |
 | F507 | PercentFormatPositionalCountMismatch | '...' % ... has 4 placeholder(s) but 2 substitution(s) |  |
 | F508 | PercentFormatStarRequiresSequence | '...' % ... `*` specifier requires sequence |  |
 | F509 | PercentFormatUnsupportedFormatCharacter | '...' % ... has unsupported format character 'c' |  |
 | F521 | StringDotFormatInvalidFormat | '...'.format(...) has invalid format string: ... |  |
-| F522 | StringDotFormatExtraNamedArguments | '...'.format(...) has unused named argument(s): ... |  |
+| F522 | StringDotFormatExtraNamedArguments | '...'.format(...) has unused named argument(s): ... | 🛠 |
 | F523 | StringDotFormatExtraPositionalArguments | '...'.format(...) has unused arguments at position(s): ... |  |
 | F524 | StringDotFormatMissingArguments | '...'.format(...) is missing argument(s) for placeholder(s): ... |  |
 | F525 | StringDotFormatMixingAutomatic | '...'.format(...) mixes automatic and manual numbering |  |
@@ -437,11 +446,13 @@ For more, see [Pyflakes](https://pypi.org/project/pyflakes/2.5.0/) on PyPI.
 | F706 | ReturnOutsideFunction | `return` statement outside of a function/method |  |
 | F707 | DefaultExceptNotLast | An `except` block as not the last exception handler |  |
 | F722 | ForwardAnnotationSyntaxError | Syntax error in forward annotation: `...` |  |
+| F811 | RedefinedWhileUnused | Redefinition of unused `...` from line 1 |  |
 | F821 | UndefinedName | Undefined name `...` |  |
 | F822 | UndefinedExport | Undefined name `...` in `__all__` |  |
 | F823 | UndefinedLocal | Local variable `...` referenced before assignment |  |
 | F831 | DuplicateArgumentName | Duplicate argument name in function definition |  |
 | F841 | UnusedVariable | Local variable `...` is assigned to but never used |  |
+| F842 | UnusedAnnotation | Local variable `...` is annotated but never used |  |
 | F901 | RaiseNotImplemented | `raise NotImplemented` should be `raise NotImplementedError` | 🛠 |

 ### pycodestyle (E, W)
@@ -475,7 +486,7 @@ For more, see [mccabe](https://pypi.org/project/mccabe/0.7.0/) on PyPI.
 | ---- | ---- | ------- | --- |
 | C901 | FunctionIsTooComplex | `...` is too complex (10) |  |

-### isort (I00)
+### isort (I)

 For more, see [isort](https://pypi.org/project/isort/5.10.1/) on PyPI.

@@ -514,6 +525,7 @@ For more, see [pydocstyle](https://pypi.org/project/pydocstyle/6.1.1/) on PyPI.
 | D214 | SectionNotOverIndented | Section is over-indented ("Returns") | 🛠 |
 | D215 | SectionUnderlineNotOverIndented | Section underline is over-indented ("Returns") | 🛠 |
 | D300 | UsesTripleQuotes | Use """triple double quotes""" |  |
+| D301 | UsesRPrefixForBackslashedContent | Use r""" if any backslashes in a docstring |  |
 | D400 | EndsInPeriod | First line should end with a period | 🛠 |
 | D402 | NoSignature | First line should not be the function's signature |  |
 | D403 | FirstLineCapitalized | First word of the first line should be properly capitalized |  |
@@ -705,7 +717,7 @@ For more, see [flake8-comprehensions](https://pypi.org/project/flake8-comprehens
 | C409 | UnnecessaryLiteralWithinTupleCall | Unnecessary `(list\|tuple)` literal passed to `tuple()` (remove the outer call to `tuple()`) | 🛠 |
 | C410 | UnnecessaryLiteralWithinListCall | Unnecessary `(list\|tuple)` literal passed to `list()` (rewrite as a `list` literal) | 🛠 |
 | C411 | UnnecessaryListCall | Unnecessary `list` call (remove the outer call to `list()`) | 🛠 |
-| C413 | UnnecessaryCallAroundSorted | Unnecessary `(list\|reversed)` call around `sorted()` |  |
+| C413 | UnnecessaryCallAroundSorted | Unnecessary `(list\|reversed)` call around `sorted()` | 🛠 |
 | C414 | UnnecessaryDoubleCastOrProcess | Unnecessary `(list\|reversed\|set\|sorted\|tuple)` call within `(list\|set\|sorted\|tuple)()` |  |
 | C415 | UnnecessarySubscriptReversal | Unnecessary subscript reversal of iterable within `(reversed\|set\|sorted)()` |  |
 | C416 | UnnecessaryComprehension | Unnecessary `(list\|set)` comprehension (rewrite using `(list\|set)()`) | 🛠 |
@@ -760,13 +772,33 @@ For more, see [flake8-return](https://pypi.org/project/flake8-return/1.2.0/) on
 | RET507 | SuperfluousElseContinue | Unnecessary `else` after `continue` statement |  |
 | RET508 | SuperfluousElseBreak | Unnecessary `else` after `break` statement |  |

-### flake8-tidy-imports (I25)
+### flake8-simplify (SIM)
+
+For more, see [flake8-simplify](https://pypi.org/project/flake8-simplify/0.19.3/) on PyPI.
+
+| Code | Name | Message | Fix |
+| ---- | ---- | ------- | --- |
+| SIM118 | KeyInDict | Use 'key in dict' instead of 'key in dict.keys() | 🛠 |
+
+### flake8-tidy-imports (TID)

 For more, see [flake8-tidy-imports](https://pypi.org/project/flake8-tidy-imports/4.8.0/) on PyPI.

 | Code | Name | Message | Fix |
 | ---- | ---- | ------- | --- |
-| I252 | BannedRelativeImport | Relative imports are banned |  |
+| TID252 | BannedRelativeImport | Relative imports are banned |  |
+
+### flake8-unused-arguments (ARG)
+
+For more, see [flake8-unused-arguments](https://pypi.org/project/flake8-unused-arguments/0.0.12/) on PyPI.
+
+| Code | Name | Message | Fix |
+| ---- | ---- | ------- | --- |
+| ARG001 | UnusedFunctionArgument | Unused function argument: `...` |  |
+| ARG002 | UnusedMethodArgument | Unused method argument: `...` |  |
+| ARG003 | UnusedClassMethodArgument | Unused class method argument: `...` |  |
+| ARG004 | UnusedStaticMethodArgument | Unused static method argument: `...` |  |
+| ARG005 | UnusedLambdaArgument | Unused lambda argument: `...` |  |

 ### eradicate (ERA)

@@ -793,12 +825,15 @@ For more, see [Pylint](https://pypi.org/project/pylint/2.15.7/) on PyPI.
 | PLC0414 | UselessImportAlias | Import alias does not rename original package | 🛠 |
 | PLC2201 | MisplacedComparisonConstant | Comparison should be ... | 🛠 |
 | PLC3002 | UnnecessaryDirectLambdaCall | Lambda expression called directly. Execute the expression inline instead. |  |
+| PLE0117 | NonlocalWithoutBinding | Nonlocal name `...` found without binding |  |
+| PLE0118 | UsedPriorGlobalDeclaration | Name `...` is used prior to global declaration on line 1 |  |
 | PLE1142 | AwaitOutsideAsync | `await` should be used within an async function |  |
 | PLR0206 | PropertyWithParameters | Cannot have defined parameters for properties |  |
-| PLR0402 | ConsiderUsingFromImport | Consider using `from ... import ...` |  |
-| PLR1701 | ConsiderMergingIsinstance | Consider merging these isinstance calls: `isinstance(..., (...))` |  |
-| PLR1722 | ConsiderUsingSysExit | Consider using `sys.exit()` | 🛠 |
+| PLR0402 | ConsiderUsingFromImport | Use `from ... import ...` in lieu of alias |  |
+| PLR1701 | ConsiderMergingIsinstance | Merge these isinstance calls: `isinstance(..., (...))` |  |
+| PLR1722 | UseSysExit | Use `sys.exit()` instead of `exit` | 🛠 |
 | PLW0120 | UselessElseOnLoop | Else clause on loop without a break statement, remove the else and de-indent all the code inside it |  |
+| PLW0602 | GlobalVariableNotAssigned | Using global for `...` but no assignment is done |  |

 ### Ruff-specific rules (RUF)

@@ -935,7 +970,7 @@ automatically convert your existing configuration.)
 Ruff can be used as a drop-in replacement for Flake8 when used (1) without or with a small number of
 plugins, (2) alongside Black, and (3) on Python 3 code.

-Under those conditions, Ruff implements every rule in Flake8, with the exception of `F811`.
+Under those conditions, Ruff implements every rule in Flake8.

 Ruff also re-implements some of the most popular Flake8 plugins and related code quality tools
 natively, including:
@@ -967,6 +1002,12 @@ natively, including:
 - [`pygrep-hooks`](https://github.com/pre-commit/pygrep-hooks) (1/10)
 - [`autoflake`](https://pypi.org/project/autoflake/) (1/7)

+Note that, in some cases, Ruff uses different error code prefixes than would be found in the
+originating Flake8 plugins. For example, Ruff uses `TID252` to represent the `I252` rule from
+`flake8-tidy-imports`. This helps minimize conflicts across plugins and allows any individual plugin
+to be toggled on or off with a single (e.g.) `--select TID`, as opposed to `--select I2` (to avoid
+conflicts with the `isort` rules, like `I001`).
+
 Beyond the rule set, Ruff suffers from the following limitations vis-à-vis Flake8:

 1. Ruff does not yet support a few Python 3.9 and 3.10 language features, including structural
@@ -1465,7 +1506,7 @@ fix = true

 A list of check code prefixes to consider autofix-able.

-**Default value**: `["A", "ANN", "B", "BLE", "C", "D", "E", "F", "FBT", "I", "M", "N", "Q", "RUF", "S", "T", "U", "W", "YTT"]`
+**Default value**: `["A", "ANN", "ARG", "B", "BLE", "C", "D", "E", "ERA", "F", "FBT", "I", "ICN", "N", "PGH", "PLC", "PLE", "PLR", "PLW", "Q", "RET", "RUF", "S", "T", "TID", "UP", "W", "YTT"]`

 **Type**: `Vec<CheckCodePrefix>`

@@ -1782,7 +1823,7 @@ The conventional aliases for imports. These aliases can be extended by the `exte

 **Default value**: `{"altair": "alt", "matplotlib.pyplot": "plt", "numpy": "np", "pandas": "pd", "seaborn": "sns"}`

-**Type**: `BTreeMap<String, String>`
+**Type**: `FxHashMap<String, String>`

 **Example usage**:

@@ -1804,7 +1845,7 @@ A mapping of modules to their conventional import aliases. These aliases will be

 **Default value**: `{}`

-**Type**: `BTreeMap<String, String>`
+**Type**: `FxHashMap<String, String>`

 **Example usage**:

@@ -1961,6 +2002,10 @@ from .utils import (
 )
 ```

+Note that this setting is only effective when combined with `combine-as-imports = true`.
+When `combine-as-imports` isn't enabled, every aliased `import from` will be given its
+own line, in which case, wrapping is not necessary.
+
 **Default value**: `false`

 **Type**: `bool`
@@ -1970,6 +2015,7 @@ from .utils import (
 ```toml
 [tool.ruff.isort]
 force-wrap-aliases = true
+combine-as-imports = true
 ```

 ---
--- a/flake8_to_ruff/Cargo.lock
+++ b/flake8_to_ruff/Cargo.lock
@@ -771,7 +771,7 @@ checksum = "0ce7134b9999ecaf8bcd65542e436736ef32ddca1b3e06094cb6ec5755203b80"

 [[package]]
 name = "flake8_to_ruff"
-version = "0.0.167"
+version = "0.0.176"
 dependencies = [
 "anyhow",
 "clap",
@@ -1975,7 +1975,7 @@ dependencies = [

 [[package]]
 name = "ruff"
-version = "0.0.167"
+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",
--- a/flake8_to_ruff/Cargo.toml
+++ b/flake8_to_ruff/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "flake8-to-ruff"
-version = "0.0.167-dev.0"
+version = "0.0.176-dev.0"
 edition = "2021"

 [lib]
--- a/flake8_to_ruff/src/converter.rs
+++ b/flake8_to_ruff/src/converter.rs
@@ -512,6 +512,7 @@ mod tests {
                CheckCodePrefix::D214,
                CheckCodePrefix::D215,
                CheckCodePrefix::D300,
+                CheckCodePrefix::D301,
                CheckCodePrefix::D400,
                CheckCodePrefix::D403,
                CheckCodePrefix::D404,
--- a/flake8_to_ruff/src/parser.rs
+++ b/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() {
--- a/flake8_to_ruff/src/plugin.rs
+++ b/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,
--- a/resources/test/fixtures/eradicate/ERA001.py
+++ b/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
--- a/resources/test/fixtures/flake8_return/RET504.py
+++ b/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:
--- a/resources/test/fixtures/flake8_simplify/SIM118.py
+++ b/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]
--- a/resources/test/fixtures/flake8_tidy_imports/TID252.py
+++ b/resources/test/fixtures/flake8_tidy_imports/TID252.py
--- a/resources/test/fixtures/flake8_unused_arguments/ARG.py
+++ b/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!")
--- a/resources/test/fixtures/isort/insert_empty_lines.pyi
+++ b/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
--- a/resources/test/fixtures/pyflakes/F504.py
+++ b/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)
--- a/resources/test/fixtures/pyflakes/F541.py
+++ b/resources/test/fixtures/pyflakes/F541.py
@@ -9,3 +9,4 @@ e = (
 )

 g = f"ghi{123:{45}}"
+h = "x" "y" f"z"
--- a/resources/test/fixtures/pyflakes/F811_0.py
+++ b/resources/test/fixtures/pyflakes/F811_0.py
@@ -0,0 +1,11 @@
+def foo(x):
+    return x
+
+
+@foo
+def bar():
+    pass
+
+
+def bar():
+    pass
--- a/resources/test/fixtures/pyflakes/F811_1.py
+++ b/resources/test/fixtures/pyflakes/F811_1.py
@@ -0,0 +1 @@
+import fu as FU, bar as FU
--- a/resources/test/fixtures/pyflakes/F811_10.py
+++ b/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
--- a/resources/test/fixtures/pyflakes/F811_11.py
+++ b/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)
--- a/resources/test/fixtures/pyflakes/F811_12.py
+++ b/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)
--- a/resources/test/fixtures/pyflakes/F811_13.py
+++ b/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)
--- a/resources/test/fixtures/pyflakes/F811_14.py
+++ b/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)
--- a/resources/test/fixtures/pyflakes/F811_15.py
+++ b/resources/test/fixtures/pyflakes/F811_15.py
@@ -0,0 +1,5 @@
+import fu
+
+
+def fu():
+    pass
--- a/resources/test/fixtures/pyflakes/F811_16.py
+++ b/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
--- a/resources/test/fixtures/pyflakes/F811_17.py
+++ b/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
--- a/resources/test/fixtures/pyflakes/F811_18.py
+++ b/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()
--- a/resources/test/fixtures/pyflakes/F811_19.py
+++ b/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
--- a/resources/test/fixtures/pyflakes/F811_2.py
+++ b/resources/test/fixtures/pyflakes/F811_2.py
@@ -0,0 +1 @@
+from moo import fu as FU, bar as FU
--- a/resources/test/fixtures/pyflakes/F811_20.py
+++ b/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)
--- a/resources/test/fixtures/pyflakes/F811_3.py
+++ b/resources/test/fixtures/pyflakes/F811_3.py
@@ -0,0 +1 @@
+import fu; fu = 3
--- a/resources/test/fixtures/pyflakes/F811_4.py
+++ b/resources/test/fixtures/pyflakes/F811_4.py
@@ -0,0 +1 @@
+import fu; fu, bar = 3
--- a/resources/test/fixtures/pyflakes/F811_5.py
+++ b/resources/test/fixtures/pyflakes/F811_5.py
@@ -0,0 +1 @@
+import fu; [fu, bar] = 3
--- a/resources/test/fixtures/pyflakes/F811_6.py
+++ b/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
--- a/resources/test/fixtures/pyflakes/F811_7.py
+++ b/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
--- a/resources/test/fixtures/pyflakes/F811_8.py
+++ b/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
--- a/resources/test/fixtures/pyflakes/F811_9.py
+++ b/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
--- a/resources/test/fixtures/pyflakes/F821_6.py
+++ b/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()
--- a/resources/test/fixtures/pyflakes/F842.py
+++ b/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
--- a/resources/test/fixtures/pylint/global_variable_not_assigned.py
+++ b/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
--- a/resources/test/fixtures/pylint/nonlocal_without_binding.py
+++ b/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
--- a/resources/test/fixtures/pylint/used_prior_global_declaration.py
+++ b/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
--- a/resources/test/fixtures/pylint/useless_else_on_loop.py
+++ b/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
--- a/ruff_dev/Cargo.toml
+++ b/ruff_dev/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "ruff_dev"
-version = "0.0.167"
+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" }
--- a/ruff_dev/src/generate_check_code_prefix.rs
+++ b/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();
@@ -113,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(),
@@ -125,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![{}],",
@@ -187,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');
        }
--- a/ruff_macros/Cargo.toml
+++ b/ruff_macros/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "ruff_macros"
-version = "0.0.161"
+version = "0.0.176"
 edition = "2021"

 [lib]
--- a/src/ast/branch_detection.rs
+++ b/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
+}
--- a/src/ast/cast.rs
+++ b/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"),
+    }
+}
--- a/src/ast/function_type.rs
+++ b/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
+    }
+}
--- a/src/ast/mod.rs
+++ b/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;
--- a/src/ast/operations.rs
+++ b/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| {
--- a/src/ast/types.rs
+++ b/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> {}
--- a/src/ast/visitor.rs
+++ b/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);
            }
--- a/src/ast/whitespace.rs
+++ b/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.
--- a/src/check_ast.rs
+++ b/src/check_ast.rs
--- a/src/check_imports.rs
+++ b/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);
    }
--- a/src/check_lines.rs
+++ b/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;
@@ -209,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 {
--- a/src/checks.rs
+++ b/src/checks.rs
@@ -87,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,
@@ -160,7 +165,7 @@ pub enum CheckCode {
    // mccabe
    C901,
    // flake8-tidy-imports
-    I252,
+    TID252,
    // flake8-return
    RET501,
    RET502,
@@ -201,6 +206,8 @@ pub enum CheckCode {
    YTT301,
    YTT302,
    YTT303,
+    // flake8-simplify
+    SIM118,
    // pyupgrade
    UP001,
    UP003,
@@ -242,6 +249,7 @@ pub enum CheckCode {
    D214,
    D215,
    D300,
+    D301,
    D400,
    D402,
    D403,
@@ -292,6 +300,12 @@ pub enum CheckCode {
    FBT001,
    FBT002,
    FBT003,
+    // flake8-unused-arguments
+    ARG001,
+    ARG002,
+    ARG003,
+    ARG004,
+    ARG005,
    // flake8-import-conventions
    ICN001,
    // Ruff
@@ -325,7 +339,9 @@ pub enum CheckCategory {
    Flake8Print,
    Flake8Quotes,
    Flake8Return,
+    Flake8Simplify,
    Flake8TidyImports,
+    Flake8UnusedArguments,
    Eradicate,
    PygrepHooks,
    Pylint,
@@ -364,6 +380,8 @@ impl CheckCategory {
            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",
@@ -392,8 +410,10 @@ impl CheckCategory {
            CheckCategory::Flake8Print => vec![CheckCodePrefix::T20],
            CheckCategory::Flake8Quotes => vec![CheckCodePrefix::Q],
            CheckCategory::Flake8Return => vec![CheckCodePrefix::RET],
-            CheckCategory::Flake8TidyImports => vec![CheckCodePrefix::I25],
-            CheckCategory::Isort => vec![CheckCodePrefix::I00],
+            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],
@@ -466,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))
            }
@@ -603,6 +631,7 @@ pub enum CheckKind {
    PercentFormatStarRequiresSequence,
    PercentFormatUnsupportedFormatCharacter(char),
    RaiseNotImplemented,
+    RedefinedWhileUnused(String, usize),
    ReturnOutsideFunction,
    StringDotFormatExtraNamedArguments(Vec<String>),
    StringDotFormatExtraPositionalArguments(Vec<String>),
@@ -612,20 +641,24 @@ 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),
@@ -722,6 +755,8 @@ pub enum CheckKind {
    SysVersion0Referenced,
    SysVersionCmpStr10,
    SysVersionSlice1Referenced,
+    // flake8-simplify
+    KeyInDict(String, String),
    // pyupgrade
    TypeOfPrimitive(Primitive),
    UselessMetaclassType,
@@ -781,6 +816,7 @@ pub enum CheckKind {
    SectionUnderlineMatchesSectionLength(String),
    SectionUnderlineNotOverIndented(String),
    SkipDocstring,
+    UsesRPrefixForBackslashedContent,
    UsesTripleQuotes,
    // pep8-naming
    InvalidClassName(String),
@@ -817,6 +853,12 @@ 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
@@ -913,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())
@@ -931,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()),
@@ -1003,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,
@@ -1046,6 +1093,8 @@ impl CheckCode {
            CheckCode::YTT303 => CheckKind::SysVersionSlice1Referenced,
            // flake8-blind-except
            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),
@@ -1090,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,
@@ -1159,6 +1209,12 @@ 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())
@@ -1188,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,
@@ -1259,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,
@@ -1329,18 +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::TID252 => CheckCategory::Flake8TidyImports,
            CheckCode::ICN001 => CheckCategory::Flake8ImportConventions,
-            CheckCode::I252 => CheckCategory::Flake8TidyImports,
            CheckCode::N801 => CheckCategory::PEP8Naming,
            CheckCode::N802 => CheckCategory::PEP8Naming,
            CheckCode::N803 => CheckCategory::PEP8Naming,
@@ -1360,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,
@@ -1388,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,
@@ -1478,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,
@@ -1550,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,
@@ -1591,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,
@@ -1650,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,
@@ -1686,6 +1762,12 @@ 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
@@ -1810,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()
            }
@@ -1858,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!(
@@ -1885,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."
@@ -1897,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()
@@ -1905,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")
@@ -2235,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())
@@ -2296,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()
@@ -2477,6 +2581,18 @@ 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}`")
@@ -2551,7 +2667,6 @@ impl CheckKind {
                | CheckKind::BlankLineBeforeSection(..)
                | CheckKind::CapitalizeSectionName(..)
                | CheckKind::CommentedOutCode
-                | CheckKind::ConsiderUsingSysExit
                | CheckKind::ConvertNamedTupleFunctionalToClass(..)
                | CheckKind::ConvertTypedDictFunctionalToClass(..)
                | CheckKind::DashedUnderlineAfterSection(..)
@@ -2565,6 +2680,7 @@ impl CheckKind {
                | CheckKind::ImplicitReturn
                | CheckKind::ImplicitReturnValue
                | CheckKind::IsLiteral
+                | CheckKind::KeyInDict(..)
                | CheckKind::MisplacedComparisonConstant(..)
                | CheckKind::NewLineAfterLastParagraph
                | CheckKind::NewLineAfterSectionName(..)
@@ -2580,6 +2696,7 @@ impl CheckKind {
                | CheckKind::NotIsTest
                | CheckKind::OneBlankLineAfterClass(..)
                | CheckKind::OneBlankLineBeforeClass(..)
+                | CheckKind::PercentFormatExtraNamedArguments(..)
                | CheckKind::PEP3120UnnecessaryCodingComment
                | CheckKind::PPrintFound
                | CheckKind::PrintFound
@@ -2592,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
@@ -2617,6 +2736,7 @@ impl CheckKind {
                | CheckKind::UnusedNOQA(..)
                | CheckKind::UsePEP585Annotation(..)
                | CheckKind::UsePEP604Annotation
+                | CheckKind::UseSysExit(..)
                | CheckKind::UselessImportAlias
                | CheckKind::UselessMetaclassType
                | CheckKind::UselessObjectInheritance(..)
@@ -2648,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),
@@ -2665,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"),
    ])
 });

--- a/src/checks_gen.rs
+++ b/src/checks_gen.rs
@@ -36,6 +36,14 @@ pub enum CheckCodePrefix {
    ANN4,
    ANN40,
    ANN401,
+    ARG,
+    ARG0,
+    ARG00,
+    ARG001,
+    ARG002,
+    ARG003,
+    ARG004,
+    ARG005,
    B,
    B0,
    B00,
@@ -131,6 +139,7 @@ pub enum CheckCodePrefix {
    D3,
    D30,
    D300,
+    D301,
    D4,
    D40,
    D400,
@@ -235,6 +244,8 @@ pub enum CheckCodePrefix {
    F72,
    F722,
    F8,
+    F81,
+    F811,
    F82,
    F821,
    F822,
@@ -243,6 +254,7 @@ pub enum CheckCodePrefix {
    F831,
    F84,
    F841,
+    F842,
    F9,
    F90,
    F901,
@@ -263,6 +275,9 @@ pub enum CheckCodePrefix {
    ICN0,
    ICN00,
    ICN001,
+    M,
+    M0,
+    M001,
    N,
    N8,
    N80,
@@ -300,6 +315,11 @@ pub enum CheckCodePrefix {
    PLC300,
    PLC3002,
    PLE,
+    PLE0,
+    PLE01,
+    PLE011,
+    PLE0117,
+    PLE0118,
    PLE1,
    PLE11,
    PLE114,
@@ -323,6 +343,9 @@ pub enum CheckCodePrefix {
    PLW01,
    PLW012,
    PLW0120,
+    PLW06,
+    PLW060,
+    PLW0602,
    Q,
    Q0,
    Q00,
@@ -359,6 +382,10 @@ pub enum CheckCodePrefix {
    S105,
    S106,
    S107,
+    SIM,
+    SIM1,
+    SIM11,
+    SIM118,
    T,
    T1,
    T10,
@@ -367,6 +394,10 @@ pub enum CheckCodePrefix {
    T20,
    T201,
    T203,
+    TID,
+    TID2,
+    TID25,
+    TID252,
    U,
    U0,
    U00,
@@ -492,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,
@@ -718,6 +775,7 @@ impl CheckCodePrefix {
                CheckCode::D214,
                CheckCode::D215,
                CheckCode::D300,
+                CheckCode::D301,
                CheckCode::D400,
                CheckCode::D402,
                CheckCode::D403,
@@ -820,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,
@@ -985,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![
@@ -1117,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],
@@ -1140,17 +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,
@@ -1238,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],
@@ -1262,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,
@@ -1371,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],
@@ -1379,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]
            }
@@ -1435,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]
            }
@@ -1444,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]
            }
@@ -1453,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]
            }
@@ -1462,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]
            }
@@ -1471,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]
            }
@@ -1480,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]
            }
@@ -1489,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]
            }
@@ -1515,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]
            }
@@ -1524,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]
            }
@@ -1533,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]
            }
@@ -1542,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]
            }
@@ -1551,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]
            }
@@ -1698,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,
@@ -1793,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,
@@ -1897,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,
@@ -1905,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,
@@ -1925,6 +2104,9 @@ impl CheckCodePrefix {
            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,
@@ -1962,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,
@@ -1985,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,
@@ -2021,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,
@@ -2029,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,
@@ -2096,6 +2294,7 @@ impl CheckCodePrefix {
 pub const CATEGORIES: &[CheckCodePrefix] = &[
    CheckCodePrefix::A,
    CheckCodePrefix::ANN,
+    CheckCodePrefix::ARG,
    CheckCodePrefix::B,
    CheckCodePrefix::BLE,
    CheckCodePrefix::C,
@@ -2116,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,
--- a/src/cli.rs
+++ b/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 {
--- a/src/docstrings/constants.rs
+++ b/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'", "\"", "'",
+];
--- a/src/docstrings/definition.rs
+++ b/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,
--- a/src/docstrings/sections.rs
+++ b/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 =
--- a/src/eradicate/detection.rs
+++ b/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());
--- a/src/flake8_annotations/helpers.rs
+++ b/src/flake8_annotations/helpers.rs
@@ -1,5 +1,6 @@
 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;
@@ -32,7 +33,7 @@ pub fn overloaded_name(checker: &Checker, definition: &Definition) -> Option<Str
    | DefinitionKind::NestedFunction(stmt)
    | DefinitionKind::Method(stmt) = definition.kind
    {
-        if visibility::is_overload(checker, stmt) {
+        if visibility::is_overload(checker, cast::decorator_list(stmt)) {
            let (name, ..) = match_function_def(stmt);
            Some(name.to_string())
        } else {
@@ -50,7 +51,7 @@ pub fn is_overload_impl(checker: &Checker, definition: &Definition, overloaded_n
    | DefinitionKind::NestedFunction(stmt)
    | DefinitionKind::Method(stmt) = definition.kind
    {
-        if visibility::is_overload(checker, stmt) {
+        if visibility::is_overload(checker, cast::decorator_list(stmt)) {
            false
        } else {
            let (name, ..) = match_function_def(stmt);
--- a/src/flake8_annotations/plugins.rs
+++ b/src/flake8_annotations/plugins.rs
@@ -1,8 +1,8 @@
 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};
@@ -192,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
@@ -264,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()),
@@ -300,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()),
--- a/src/flake8_bugbear/plugins/duplicate_exceptions.rs
+++ b/src/flake8_bugbear/plugins/duplicate_exceptions.rs
@@ -1,6 +1,5 @@
-use std::collections::BTreeSet;
-
 use itertools::Itertools;
+use rustc_hash::FxHashSet;
 use rustpython_ast::{
    Excepthandler, ExcepthandlerKind, Expr, ExprContext, ExprKind, Location, Stmt,
 };
@@ -27,9 +26,9 @@ fn duplicate_handler_exceptions<'a>(
    checker: &mut Checker,
    expr: &'a Expr,
    elts: &'a [Expr],
-) -> BTreeSet<Vec<&'a str>> {
-    let mut seen: BTreeSet<Vec<&str>> = BTreeSet::default();
-    let mut duplicates: BTreeSet<Vec<&str>> = BTreeSet::default();
+) -> FxHashSet<Vec<&'a str>> {
+    let mut seen: FxHashSet<Vec<&str>> = FxHashSet::default();
+    let mut duplicates: FxHashSet<Vec<&str>> = FxHashSet::default();
    let mut unique_elts: Vec<&Expr> = Vec::default();
    for type_ in elts {
        let call_path = helpers::collect_call_paths(type_);
@@ -76,8 +75,8 @@ fn duplicate_handler_exceptions<'a>(
 }

 pub fn duplicate_exceptions(checker: &mut Checker, stmt: &Stmt, handlers: &[Excepthandler]) {
-    let mut seen: BTreeSet<Vec<&str>> = BTreeSet::default();
-    let mut duplicates: BTreeSet<Vec<&str>> = BTreeSet::default();
+    let mut seen: FxHashSet<Vec<&str>> = FxHashSet::default();
+    let mut duplicates: FxHashSet<Vec<&str>> = FxHashSet::default();
    for handler in handlers {
        let ExcepthandlerKind::ExceptHandler { type_: Some(type_), .. } = &handler.node else {
            continue;
--- a/src/flake8_import_conventions/checks.rs
+++ b/src/flake8_import_conventions/checks.rs
@@ -1,5 +1,4 @@
-use std::collections::BTreeMap;
-
+use rustc_hash::FxHashMap;
 use rustpython_ast::Stmt;

 use crate::ast::types::Range;
@@ -10,7 +9,7 @@ pub fn check_conventional_import(
    import_from: &Stmt,
    name: &str,
    asname: Option<&str>,
-    conventions: &BTreeMap<String, String>,
+    conventions: &FxHashMap<String, String>,
 ) -> Option<Check> {
    let mut is_valid_import = true;
    if let Some(expected_alias) = conventions.get(name) {
--- a/src/flake8_import_conventions/mod.rs
+++ b/src/flake8_import_conventions/mod.rs
@@ -3,10 +3,11 @@ pub mod settings;

 #[cfg(test)]
 mod tests {
-    use std::collections::BTreeMap;
+
    use std::path::Path;

    use anyhow::Result;
+    use rustc_hash::FxHashMap;

    use crate::checks::CheckCode;
    use crate::linter::test_path;
@@ -33,7 +34,7 @@ mod tests {
                    flake8_import_conventions::settings::Settings::from_options(
                        flake8_import_conventions::settings::Options {
                            aliases: None,
-                            extend_aliases: Some(BTreeMap::from([
+                            extend_aliases: Some(FxHashMap::from_iter([
                                ("dask.array".to_string(), "da".to_string()),
                                ("dask.dataframe".to_string(), "dd".to_string()),
                            ])),
@@ -56,7 +57,7 @@ mod tests {
                flake8_import_conventions:
                    flake8_import_conventions::settings::Settings::from_options(
                        flake8_import_conventions::settings::Options {
-                            aliases: Some(BTreeMap::from([
+                            aliases: Some(FxHashMap::from_iter([
                                ("altair".to_string(), "alt".to_string()),
                                ("matplotlib.pyplot".to_string(), "plt".to_string()),
                                ("pandas".to_string(), "pd".to_string()),
@@ -83,7 +84,7 @@ mod tests {
                    flake8_import_conventions::settings::Settings::from_options(
                        flake8_import_conventions::settings::Options {
                            aliases: None,
-                            extend_aliases: Some(BTreeMap::from([(
+                            extend_aliases: Some(FxHashMap::from_iter([(
                                "numpy".to_string(),
                                "nmp".to_string(),
                            )])),
--- a/src/flake8_import_conventions/settings.rs
+++ b/src/flake8_import_conventions/settings.rs
@@ -1,8 +1,10 @@
 //! Settings for import conventions.

-use std::collections::BTreeMap;
+use std::hash::{Hash, Hasher};

+use itertools::Itertools;
 use ruff_macros::ConfigurationOptions;
+use rustc_hash::FxHashMap;
 use serde::{Deserialize, Serialize};

 const CONVENTIONAL_ALIASES: &[(&str, &str)] = &[
@@ -20,7 +22,7 @@ pub struct Options {
        doc = "The conventional aliases for imports. These aliases can be extended by the \
               `extend_aliases` option.",
        default = r#"{"altair": "alt", "matplotlib.pyplot": "plt", "numpy": "np", "pandas": "pd", "seaborn": "sns"}"#,
-        value_type = "BTreeMap<String, String>",
+        value_type = "FxHashMap<String, String>",
        example = r#"
            # Declare the default aliases.
            altair = "alt"
@@ -30,33 +32,41 @@ pub struct Options {
            seaborn = "sns"
        "#
    )]
-    pub aliases: Option<BTreeMap<String, String>>,
+    pub aliases: Option<FxHashMap<String, String>>,
    #[option(
        doc = "A mapping of modules to their conventional import aliases. These aliases will be \
               added to the `aliases` mapping.",
        default = r#"{}"#,
-        value_type = "BTreeMap<String, String>",
+        value_type = "FxHashMap<String, String>",
        example = r#"
            # Declare a custom alias for the `matplotlib` module.
            "dask.dataframe" = "dd"
        "#
    )]
-    pub extend_aliases: Option<BTreeMap<String, String>>,
+    pub extend_aliases: Option<FxHashMap<String, String>>,
 }

-#[derive(Debug, Hash)]
+#[derive(Debug)]
 pub struct Settings {
-    pub aliases: BTreeMap<String, String>,
+    pub aliases: FxHashMap<String, String>,
 }

-fn default_aliases() -> BTreeMap<String, String> {
+impl Hash for Settings {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        for value in self.aliases.iter().sorted() {
+            value.hash(state);
+        }
+    }
+}
+
+fn default_aliases() -> FxHashMap<String, String> {
    CONVENTIONAL_ALIASES
        .iter()
        .map(|(k, v)| ((*k).to_string(), (*v).to_string()))
-        .collect::<BTreeMap<_, _>>()
+        .collect::<FxHashMap<_, _>>()
 }

-fn resolve_aliases(options: Options) -> BTreeMap<String, String> {
+fn resolve_aliases(options: Options) -> FxHashMap<String, String> {
    let mut aliases = match options.aliases {
        Some(options_aliases) => options_aliases,
        None => default_aliases(),
--- a/src/flake8_print/plugins/print_call.rs
+++ b/src/flake8_print/plugins/print_call.rs
@@ -19,24 +19,14 @@ pub fn print_call(checker: &mut Checker, expr: &Expr, func: &Expr) {
    };

    if checker.patch(check.kind.code()) {
-        let context = checker.binding_context();
-        if matches!(
-            checker.parents[context.defined_by].node,
-            StmtKind::Expr { .. }
-        ) {
-            let deleted: Vec<&Stmt> = checker
-                .deletions
-                .iter()
-                .map(|index| checker.parents[*index])
-                .collect();
-            match helpers::remove_stmt(
-                checker.parents[context.defined_by],
-                context.defined_in.map(|index| checker.parents[index]),
-                &deleted,
-            ) {
+        let defined_by = checker.current_parent();
+        let defined_in = checker.current_grandparent();
+        if matches!(defined_by.0.node, StmtKind::Expr { .. }) {
+            let deleted: Vec<&Stmt> = checker.deletions.iter().map(|node| node.0).collect();
+            match helpers::remove_stmt(defined_by.0, defined_in.map(|node| node.0), &deleted) {
                Ok(fix) => {
                    if fix.content.is_empty() || fix.content == "pass" {
-                        checker.deletions.insert(context.defined_by);
+                        checker.deletions.insert(defined_by.clone());
                    }
                    check.amend(fix);
                }
--- a/src/flake8_return/visitor.rs
+++ b/src/flake8_return/visitor.rs
@@ -18,6 +18,8 @@ pub struct Stack<'a> {
 #[derive(Default)]
 pub struct ReturnVisitor<'a> {
    pub stack: Stack<'a>,
+    // If we're in an f-string, the location of the defining expression.
+    in_f_string: Option<Location>,
 }

 impl<'a> ReturnVisitor<'a> {
@@ -34,7 +36,7 @@ impl<'a> ReturnVisitor<'a> {
                    .assigns
                    .entry(id)
                    .or_insert_with(Vec::new)
-                    .push(expr.location);
+                    .push(self.in_f_string.unwrap_or(expr.location));
                return;
            }
            _ => {}
@@ -70,7 +72,7 @@ impl<'a> Visitor<'a> for ReturnVisitor<'a> {
                        .refs
                        .entry(id)
                        .or_insert_with(Vec::new)
-                        .push(value.location);
+                        .push(self.in_f_string.unwrap_or(value.location));
                }

                visitor::walk_expr(self, value);
@@ -111,7 +113,13 @@ impl<'a> Visitor<'a> for ReturnVisitor<'a> {
                    .refs
                    .entry(id)
                    .or_insert_with(Vec::new)
-                    .push(expr.location);
+                    .push(self.in_f_string.unwrap_or(expr.location));
+            }
+            ExprKind::JoinedStr { .. } => {
+                let prev_in_f_string = self.in_f_string;
+                self.in_f_string = Some(expr.location);
+                visitor::walk_expr(self, expr);
+                self.in_f_string = prev_in_f_string;
            }
            _ => visitor::walk_expr(self, expr),
        }
--- a/src/flake8_simplify/mod.rs
+++ b/src/flake8_simplify/mod.rs
@@ -0,0 +1,29 @@
+pub mod plugins;
+
+#[cfg(test)]
+mod tests {
+    use std::convert::AsRef;
+    use std::path::Path;
+
+    use anyhow::Result;
+    use test_case::test_case;
+
+    use crate::checks::CheckCode;
+    use crate::linter::test_path;
+    use crate::settings;
+
+    #[test_case(CheckCode::SIM118, Path::new("SIM118.py"); "SIM118")]
+    fn checks(check_code: CheckCode, path: &Path) -> Result<()> {
+        let snapshot = format!("{}_{}", check_code.as_ref(), path.to_string_lossy());
+        let mut checks = test_path(
+            Path::new("./resources/test/fixtures/flake8_simplify")
+                .join(path)
+                .as_path(),
+            &settings::Settings::for_rule(check_code),
+            true,
+        )?;
+        checks.sort_by_key(|check| check.location);
+        insta::assert_yaml_snapshot!(snapshot, checks);
+        Ok(())
+    }
+}
--- a/src/flake8_simplify/plugins/key_in_dict.rs
+++ b/src/flake8_simplify/plugins/key_in_dict.rs
@@ -0,0 +1,74 @@
+use rustpython_ast::{Cmpop, Expr, ExprKind};
+
+use crate::ast::types::Range;
+use crate::autofix::Fix;
+use crate::check_ast::Checker;
+use crate::checks::{Check, CheckCode, CheckKind};
+
+/// SIM118
+fn key_in_dict(checker: &mut Checker, left: &Expr, right: &Expr, range: Range) {
+    let ExprKind::Call {
+        func,
+        args,
+        keywords,
+    } = &right.node else {
+        return;
+    };
+    if !(args.is_empty() && keywords.is_empty()) {
+        return;
+    }
+
+    let ExprKind::Attribute { attr, value, .. } = &func.node else {
+        return;
+    };
+    if attr != "keys" {
+        return;
+    }
+
+    let mut check = Check::new(
+        CheckKind::KeyInDict(left.to_string(), value.to_string()),
+        range,
+    );
+    if checker.patch(&CheckCode::SIM118) {
+        let content = right.to_string().replace(".keys()", "");
+        check.amend(Fix::replacement(
+            content,
+            right.location,
+            right.end_location.unwrap(),
+        ));
+    }
+    checker.add_check(check);
+}
+
+/// SIM118 in a for loop
+pub fn key_in_dict_for(checker: &mut Checker, target: &Expr, iter: &Expr) {
+    key_in_dict(
+        checker,
+        target,
+        iter,
+        Range {
+            location: target.location,
+            end_location: iter.end_location.unwrap(),
+        },
+    );
+}
+
+/// SIM118 in a comparison
+pub fn key_in_dict_compare(
+    checker: &mut Checker,
+    expr: &Expr,
+    left: &Expr,
+    ops: &[Cmpop],
+    comparators: &[Expr],
+) {
+    if !matches!(ops[..], [Cmpop::In]) {
+        return;
+    }
+
+    if comparators.len() != 1 {
+        return;
+    }
+    let right = comparators.first().unwrap();
+
+    key_in_dict(checker, left, right, Range::from_located(expr));
+}
--- a/src/flake8_simplify/plugins/mod.rs
+++ b/src/flake8_simplify/plugins/mod.rs
@@ -0,0 +1,3 @@
+pub use key_in_dict::{key_in_dict_compare, key_in_dict_for};
+
+mod key_in_dict;
--- a/src/flake8_simplify/snapshots/ruff__flake8_simplifytestsSIM118_SIM118.py.snap
+++ b/src/flake8_simplify/snapshots/ruff__flake8_simplifytestsSIM118_SIM118.py.snap
@@ -0,0 +1,77 @@
+---
+source: src/flake8_simplify/mod.rs
+expression: checks
+---
+- kind:
+    KeyInDict:
+      - key
+      - dict
+  location:
+    row: 1
+    column: 0
+  end_location:
+    row: 1
+    column: 18
+  fix:
+    content: dict
+    location:
+      row: 1
+      column: 7
+    end_location:
+      row: 1
+      column: 18
+- kind:
+    KeyInDict:
+      - "foo['bar']"
+      - dict
+  location:
+    row: 3
+    column: 0
+  end_location:
+    row: 3
+    column: 25
+  fix:
+    content: dict
+    location:
+      row: 3
+      column: 14
+    end_location:
+      row: 3
+      column: 25
+- kind:
+    KeyInDict:
+      - foo()
+      - dict
+  location:
+    row: 5
+    column: 0
+  end_location:
+    row: 5
+    column: 20
+  fix:
+    content: dict
+    location:
+      row: 5
+      column: 9
+    end_location:
+      row: 5
+      column: 20
+- kind:
+    KeyInDict:
+      - key
+      - dict
+  location:
+    row: 7
+    column: 4
+  end_location:
+    row: 7
+    column: 22
+  fix:
+    content: dict
+    location:
+      row: 7
+      column: 11
+    end_location:
+      row: 7
+      column: 22
+
--- a/src/flake8_tidy_imports/mod.rs
+++ b/src/flake8_tidy_imports/mod.rs
@@ -15,12 +15,12 @@ mod tests {
    #[test]
    fn ban_parent_imports() -> Result<()> {
        let mut checks = test_path(
-            Path::new("./resources/test/fixtures/flake8_tidy_imports/I252.py"),
+            Path::new("./resources/test/fixtures/flake8_tidy_imports/TID252.py"),
            &Settings {
                flake8_tidy_imports: flake8_tidy_imports::settings::Settings {
                    ban_relative_imports: Strictness::Parents,
                },
-                ..Settings::for_rules(vec![CheckCode::I252])
+                ..Settings::for_rules(vec![CheckCode::TID252])
            },
            true,
        )?;
@@ -32,12 +32,12 @@ mod tests {
    #[test]
    fn ban_all_imports() -> Result<()> {
        let mut checks = test_path(
-            Path::new("./resources/test/fixtures/flake8_tidy_imports/I252.py"),
+            Path::new("./resources/test/fixtures/flake8_tidy_imports/TID252.py"),
            &Settings {
                flake8_tidy_imports: flake8_tidy_imports::settings::Settings {
                    ban_relative_imports: Strictness::All,
                },
-                ..Settings::for_rules(vec![CheckCode::I252])
+                ..Settings::for_rules(vec![CheckCode::TID252])
            },
            true,
        )?;
--- a/src/flake8_unused_arguments/helpers.rs
+++ b/src/flake8_unused_arguments/helpers.rs
@@ -0,0 +1,19 @@
+use rustpython_ast::{Constant, ExprKind, Stmt, StmtKind};
+
+pub fn is_empty(body: &[Stmt]) -> bool {
+    match &body {
+        [] => true,
+        // Also allow: raise NotImplementedError, raise NotImplemented
+        [stmt] => match &stmt.node {
+            StmtKind::Pass => true,
+            StmtKind::Expr { value } => match &value.node {
+                ExprKind::Constant { value, .. } => {
+                    matches!(value, Constant::Str(_) | Constant::Ellipsis)
+                }
+                _ => false,
+            },
+            _ => false,
+        },
+        _ => false,
+    }
+}
--- a/src/flake8_unused_arguments/mod.rs
+++ b/src/flake8_unused_arguments/mod.rs
@@ -0,0 +1,35 @@
+mod helpers;
+pub mod plugins;
+mod types;
+
+#[cfg(test)]
+mod tests {
+    use std::convert::AsRef;
+    use std::path::Path;
+
+    use anyhow::Result;
+    use test_case::test_case;
+
+    use crate::checks::CheckCode;
+    use crate::linter::test_path;
+    use crate::settings;
+
+    #[test_case(CheckCode::ARG001, Path::new("ARG.py"); "ARG001")]
+    #[test_case(CheckCode::ARG002, Path::new("ARG.py"); "ARG002")]
+    #[test_case(CheckCode::ARG003, Path::new("ARG.py"); "ARG003")]
+    #[test_case(CheckCode::ARG004, Path::new("ARG.py"); "ARG004")]
+    #[test_case(CheckCode::ARG005, Path::new("ARG.py"); "ARG005")]
+    fn checks(check_code: CheckCode, path: &Path) -> Result<()> {
+        let snapshot = format!("{}_{}", check_code.as_ref(), path.to_string_lossy());
+        let mut checks = test_path(
+            Path::new("./resources/test/fixtures/flake8_unused_arguments")
+                .join(path)
+                .as_path(),
+            &settings::Settings::for_rule(check_code),
+            true,
+        )?;
+        checks.sort_by_key(|check| check.location);
+        insta::assert_yaml_snapshot!(snapshot, checks);
+        Ok(())
+    }
+}
--- a/src/flake8_unused_arguments/plugins.rs
+++ b/src/flake8_unused_arguments/plugins.rs
@@ -0,0 +1,199 @@
+use std::iter;
+
+use regex::Regex;
+use rustc_hash::FxHashMap;
+use rustpython_ast::{Arg, Arguments};
+
+use crate::ast::function_type;
+use crate::ast::function_type::FunctionType;
+use crate::ast::helpers::collect_arg_names;
+use crate::ast::types::{Binding, BindingKind, FunctionDef, Lambda, Scope, ScopeKind};
+use crate::check_ast::Checker;
+use crate::flake8_unused_arguments::helpers;
+use crate::flake8_unused_arguments::types::Argumentable;
+use crate::{visibility, Check};
+
+/// Check a plain function for unused arguments.
+fn function(
+    argumentable: &Argumentable,
+    args: &Arguments,
+    values: &FxHashMap<&str, usize>,
+    bindings: &[Binding],
+    dummy_variable_rgx: &Regex,
+) -> Vec<Check> {
+    let mut checks: Vec<Check> = vec![];
+    for arg_name in collect_arg_names(args) {
+        if let Some(binding) = values.get(arg_name).map(|index| &bindings[*index]) {
+            if binding.used.is_none()
+                && matches!(binding.kind, BindingKind::Argument)
+                && !dummy_variable_rgx.is_match(arg_name)
+            {
+                checks.push(Check::new(
+                    argumentable.check_for(arg_name.to_string()),
+                    binding.range,
+                ));
+            }
+        }
+    }
+    checks
+}
+
+/// Check a method for unused arguments.
+fn method(
+    argumentable: &Argumentable,
+    args: &Arguments,
+    values: &FxHashMap<&str, usize>,
+    bindings: &[Binding],
+    dummy_variable_rgx: &Regex,
+) -> Vec<Check> {
+    let mut checks: Vec<Check> = vec![];
+    for arg in args
+        .posonlyargs
+        .iter()
+        .chain(args.args.iter())
+        .skip(1)
+        .chain(args.kwonlyargs.iter())
+        .chain(iter::once::<Option<&Arg>>(args.vararg.as_deref()).flatten())
+        .chain(iter::once::<Option<&Arg>>(args.kwarg.as_deref()).flatten())
+    {
+        if let Some(binding) = values
+            .get(&arg.node.arg.as_str())
+            .map(|index| &bindings[*index])
+        {
+            if binding.used.is_none()
+                && matches!(binding.kind, BindingKind::Argument)
+                && !dummy_variable_rgx.is_match(arg.node.arg.as_str())
+            {
+                checks.push(Check::new(
+                    argumentable.check_for(arg.node.arg.to_string()),
+                    binding.range,
+                ));
+            }
+        }
+    }
+    checks
+}
+
+/// ARG001, ARG002, ARG003, ARG004, ARG005
+pub fn unused_arguments(
+    checker: &Checker,
+    parent: &Scope,
+    scope: &Scope,
+    bindings: &[Binding],
+) -> Vec<Check> {
+    match &scope.kind {
+        ScopeKind::Function(FunctionDef {
+            name,
+            args,
+            body,
+            decorator_list,
+            ..
+        }) => {
+            match function_type::classify(
+                parent,
+                name,
+                decorator_list,
+                &checker.from_imports,
+                &checker.import_aliases,
+                &checker.settings.pep8_naming.classmethod_decorators,
+                &checker.settings.pep8_naming.staticmethod_decorators,
+            ) {
+                FunctionType::Function => {
+                    if checker
+                        .settings
+                        .enabled
+                        .contains(Argumentable::Function.check_code())
+                    {
+                        function(
+                            &Argumentable::Function,
+                            args,
+                            &scope.values,
+                            bindings,
+                            &checker.settings.dummy_variable_rgx,
+                        )
+                    } else {
+                        vec![]
+                    }
+                }
+                FunctionType::Method => {
+                    if checker
+                        .settings
+                        .enabled
+                        .contains(Argumentable::Method.check_code())
+                        && !helpers::is_empty(body)
+                        && !visibility::is_abstract(checker, decorator_list)
+                        && !visibility::is_override(checker, decorator_list)
+                    {
+                        method(
+                            &Argumentable::Method,
+                            args,
+                            &scope.values,
+                            bindings,
+                            &checker.settings.dummy_variable_rgx,
+                        )
+                    } else {
+                        vec![]
+                    }
+                }
+                FunctionType::ClassMethod => {
+                    if checker
+                        .settings
+                        .enabled
+                        .contains(Argumentable::ClassMethod.check_code())
+                        && !helpers::is_empty(body)
+                        && !visibility::is_abstract(checker, decorator_list)
+                        && !visibility::is_override(checker, decorator_list)
+                    {
+                        method(
+                            &Argumentable::ClassMethod,
+                            args,
+                            &scope.values,
+                            bindings,
+                            &checker.settings.dummy_variable_rgx,
+                        )
+                    } else {
+                        vec![]
+                    }
+                }
+                FunctionType::StaticMethod => {
+                    if checker
+                        .settings
+                        .enabled
+                        .contains(Argumentable::StaticMethod.check_code())
+                        && !helpers::is_empty(body)
+                        && !visibility::is_abstract(checker, decorator_list)
+                        && !visibility::is_override(checker, decorator_list)
+                    {
+                        function(
+                            &Argumentable::StaticMethod,
+                            args,
+                            &scope.values,
+                            bindings,
+                            &checker.settings.dummy_variable_rgx,
+                        )
+                    } else {
+                        vec![]
+                    }
+                }
+            }
+        }
+        ScopeKind::Lambda(Lambda { args, .. }) => {
+            if checker
+                .settings
+                .enabled
+                .contains(Argumentable::Lambda.check_code())
+            {
+                function(
+                    &Argumentable::Lambda,
+                    args,
+                    &scope.values,
+                    bindings,
+                    &checker.settings.dummy_variable_rgx,
+                )
+            } else {
+                vec![]
+            }
+        }
+        _ => unreachable!("Expected ScopeKind::Function | ScopeKind::Lambda"),
+    }
+}
--- a/src/flake8_unused_arguments/snapshots/ruff__flake8_unused_argumentstestsARG001_ARG.py.snap
+++ b/src/flake8_unused_arguments/snapshots/ruff__flake8_unused_argumentstestsARG001_ARG.py.snap
@@ -0,0 +1,77 @@
+---
+source: src/flake8_unused_arguments/mod.rs
+expression: checks
+---
+- kind:
+    UnusedFunctionArgument: self
+  location:
+    row: 8
+    column: 6
+  end_location:
+    row: 8
+    column: 10
+  fix: ~
+- kind:
+    UnusedFunctionArgument: x
+  location:
+    row: 8
+    column: 12
+  end_location:
+    row: 8
+    column: 13
+  fix: ~
+- kind:
+    UnusedFunctionArgument: cls
+  location:
+    row: 12
+    column: 6
+  end_location:
+    row: 12
+    column: 9
+  fix: ~
+- kind:
+    UnusedFunctionArgument: x
+  location:
+    row: 12
+    column: 11
+  end_location:
+    row: 12
+    column: 12
+  fix: ~
+- kind:
+    UnusedFunctionArgument: self
+  location:
+    row: 16
+    column: 6
+  end_location:
+    row: 16
+    column: 10
+  fix: ~
+- kind:
+    UnusedFunctionArgument: x
+  location:
+    row: 16
+    column: 12
+  end_location:
+    row: 16
+    column: 13
+  fix: ~
+- kind:
+    UnusedFunctionArgument: cls
+  location:
+    row: 20
+    column: 6
+  end_location:
+    row: 20
+    column: 9
+  fix: ~
+- kind:
+    UnusedFunctionArgument: x
+  location:
+    row: 20
+    column: 11
+  end_location:
+    row: 20
+    column: 12
+  fix: ~
+
--- a/src/flake8_unused_arguments/snapshots/ruff__flake8_unused_argumentstestsARG002_ARG.py.snap
+++ b/src/flake8_unused_arguments/snapshots/ruff__flake8_unused_argumentstestsARG002_ARG.py.snap
@@ -0,0 +1,32 @@
+---
+source: src/flake8_unused_arguments/mod.rs
+expression: checks
+---
+- kind:
+    UnusedMethodArgument: x
+  location:
+    row: 34
+    column: 16
+  end_location:
+    row: 34
+    column: 17
+  fix: ~
+- kind:
+    UnusedMethodArgument: x
+  location:
+    row: 37
+    column: 19
+  end_location:
+    row: 37
+    column: 20
+  fix: ~
+- kind:
+    UnusedMethodArgument: x
+  location:
+    row: 40
+    column: 15
+  end_location:
+    row: 40
+    column: 16
+  fix: ~
+
--- a/src/flake8_unused_arguments/snapshots/ruff__flake8_unused_argumentstestsARG003_ARG.py.snap
+++ b/src/flake8_unused_arguments/snapshots/ruff__flake8_unused_argumentstestsARG003_ARG.py.snap
@@ -0,0 +1,14 @@
+---
+source: src/flake8_unused_arguments/mod.rs
+expression: checks
+---
+- kind:
+    UnusedClassMethodArgument: x
+  location:
+    row: 44
+    column: 15
+  end_location:
+    row: 44
+    column: 16
+  fix: ~
+
--- a/src/flake8_unused_arguments/snapshots/ruff__flake8_unused_argumentstestsARG004_ARG.py.snap
+++ b/src/flake8_unused_arguments/snapshots/ruff__flake8_unused_argumentstestsARG004_ARG.py.snap
@@ -0,0 +1,32 @@
+---
+source: src/flake8_unused_arguments/mod.rs
+expression: checks
+---
+- kind:
+    UnusedStaticMethodArgument: cls
+  location:
+    row: 48
+    column: 10
+  end_location:
+    row: 48
+    column: 13
+  fix: ~
+- kind:
+    UnusedStaticMethodArgument: x
+  location:
+    row: 48
+    column: 15
+  end_location:
+    row: 48
+    column: 16
+  fix: ~
+- kind:
+    UnusedStaticMethodArgument: x
+  location:
+    row: 52
+    column: 10
+  end_location:
+    row: 52
+    column: 11
+  fix: ~
+
--- a/src/flake8_unused_arguments/snapshots/ruff__flake8_unused_argumentstestsARG005_ARG.py.snap
+++ b/src/flake8_unused_arguments/snapshots/ruff__flake8_unused_argumentstestsARG005_ARG.py.snap
@@ -0,0 +1,14 @@
+---
+source: src/flake8_unused_arguments/mod.rs
+expression: checks
+---
+- kind:
+    UnusedLambdaArgument: x
+  location:
+    row: 27
+    column: 7
+  end_location:
+    row: 27
+    column: 8
+  fix: ~
+
--- a/src/flake8_unused_arguments/types.rs
+++ b/src/flake8_unused_arguments/types.rs
@@ -0,0 +1,32 @@
+use crate::checks::{CheckCode, CheckKind};
+
+/// An AST node that can contain arguments.
+pub enum Argumentable {
+    Function,
+    Method,
+    ClassMethod,
+    StaticMethod,
+    Lambda,
+}
+
+impl Argumentable {
+    pub fn check_for(&self, name: String) -> CheckKind {
+        match self {
+            Argumentable::Function => CheckKind::UnusedFunctionArgument(name),
+            Argumentable::Method => CheckKind::UnusedMethodArgument(name),
+            Argumentable::ClassMethod => CheckKind::UnusedClassMethodArgument(name),
+            Argumentable::StaticMethod => CheckKind::UnusedStaticMethodArgument(name),
+            Argumentable::Lambda => CheckKind::UnusedLambdaArgument(name),
+        }
+    }
+
+    pub fn check_code(&self) -> &CheckCode {
+        match self {
+            Argumentable::Function => &CheckCode::ARG001,
+            Argumentable::Method => &CheckCode::ARG002,
+            Argumentable::ClassMethod => &CheckCode::ARG003,
+            Argumentable::StaticMethod => &CheckCode::ARG004,
+            Argumentable::Lambda => &CheckCode::ARG005,
+        }
+    }
+}
--- a/src/fs.rs
+++ b/src/fs.rs
@@ -1,5 +1,4 @@
 use std::borrow::Cow;
-use std::collections::BTreeSet;
 use std::fs::File;
 use std::io::{BufReader, Read};
 use std::path::{Path, PathBuf};
@@ -8,6 +7,7 @@ use anyhow::{anyhow, Result};
 use globset::GlobMatcher;
 use log::debug;
 use path_absolutize::{path_dedot, Absolutize};
+use rustc_hash::FxHashSet;
 use walkdir::{DirEntry, WalkDir};

 use crate::checks::CheckCode;
@@ -83,8 +83,8 @@ pub fn iter_python_files<'a>(
 /// Create tree set with codes matching the pattern/code pairs.
 pub(crate) fn ignores_from_path<'a>(
    path: &Path,
-    pattern_code_pairs: &'a [(GlobMatcher, GlobMatcher, BTreeSet<CheckCode>)],
-) -> Result<BTreeSet<&'a CheckCode>> {
+    pattern_code_pairs: &'a [(GlobMatcher, GlobMatcher, FxHashSet<CheckCode>)],
+) -> Result<FxHashSet<&'a CheckCode>> {
    let (file_path, file_basename) = extract_path_names(path)?;
    Ok(pattern_code_pairs
        .iter()
--- a/src/isort/mod.rs
+++ b/src/isort/mod.rs
@@ -559,6 +559,7 @@ mod tests {
    #[test_case(Path::new("force_wrap_aliases.py"))]
    #[test_case(Path::new("import_from_after_import.py"))]
    #[test_case(Path::new("insert_empty_lines.py"))]
+    #[test_case(Path::new("insert_empty_lines.pyi"))]
    #[test_case(Path::new("leading_prefix.py"))]
    #[test_case(Path::new("no_reorder_within_section.py"))]
    #[test_case(Path::new("no_wrap_star.py"))]
--- a/src/isort/plugins.rs
+++ b/src/isort/plugins.rs
@@ -19,14 +19,12 @@ fn extract_range(body: &[&Stmt]) -> Range {
    }
 }

-fn extract_indentation(body: &[&Stmt], locator: &SourceCodeLocator) -> String {
+fn extract_indentation_range(body: &[&Stmt]) -> Range {
    let location = body.first().unwrap().location;
-    let range = Range {
+    Range {
        location: Location::new(location.row(), 0),
        end_location: location,
-    };
-    let existing = locator.slice_source_code_range(&range);
-    leading_space(&existing)
+    }
 }

 /// I001
@@ -36,8 +34,10 @@ pub fn check_imports(
    settings: &Settings,
    autofix: bool,
 ) -> Option<Check> {
+    let indentation = locator.slice_source_code_range(&extract_indentation_range(&block.imports));
+    let indentation = leading_space(&indentation);
+
    let range = extract_range(&block.imports);
-    let indentation = extract_indentation(&block.imports, locator);

    // Extract comments. Take care to grab any inline comments from the last line.
    let comments = comments::collect_comments(
@@ -77,7 +77,7 @@ pub fn check_imports(
            if has_leading_content {
                content.push('\n');
            }
-            content.push_str(&indent(&expected, &indentation));
+            content.push_str(&indent(&expected, indentation));
            check.amend(Fix::replacement(
                content,
                // Preserve leading prefix (but put the imports on a new line).
@@ -104,7 +104,7 @@ pub fn check_imports(
            let mut check = Check::new(CheckKind::UnsortedImports, range);
            if autofix && settings.fixable.contains(check.kind.code()) {
                check.amend(Fix::replacement(
-                    indent(&expected, &indentation),
+                    indent(&expected, indentation),
                    range.location,
                    range.end_location,
                ));
--- a/src/isort/settings.rs
+++ b/src/isort/settings.rs
@@ -32,11 +32,16 @@ pub struct Options {
                test_id as test_id
            )
            ```
+
+            Note that this setting is only effective when combined with `combine-as-imports = true`.
+            When `combine-as-imports` isn't enabled, every aliased `import from` will be given its
+            own line, in which case, wrapping is not necessary.
        "#,
        default = r#"false"#,
        value_type = "bool",
        example = r#"
            force-wrap-aliases = true
+            combine-as-imports = true
        "#
    )]
    pub force_wrap_aliases: Option<bool>,
--- a/src/isort/snapshots/ruffisorttests__insert_empty_lines.pyi.snap
+++ b/src/isort/snapshots/ruffisorttests__insert_empty_lines.pyi.snap
@@ -0,0 +1,65 @@
+---
+source: src/isort/mod.rs
+expression: checks
+---
+- kind: UnsortedImports
+  location:
+    row: 1
+    column: 0
+  end_location:
+    row: 3
+    column: 0
+  fix:
+    content: "import a\nimport b\n\n"
+    location:
+      row: 1
+      column: 0
+    end_location:
+      row: 3
+      column: 0
+- kind: UnsortedImports
+  location:
+    row: 4
+    column: 0
+  end_location:
+    row: 6
+    column: 0
+  fix:
+    content: "import os\nimport sys\n\n"
+    location:
+      row: 4
+      column: 0
+    end_location:
+      row: 6
+      column: 0
+- kind: UnsortedImports
+  location:
+    row: 14
+    column: 0
+  end_location:
+    row: 16
+    column: 0
+  fix:
+    content: "import os\nimport sys\n\n"
+    location:
+      row: 14
+      column: 0
+    end_location:
+      row: 16
+      column: 0
+- kind: UnsortedImports
+  location:
+    row: 33
+    column: 0
+  end_location:
+    row: 35
+    column: 0
+  fix:
+    content: "    import collections\n    import typing\n\n"
+    location:
+      row: 33
+      column: 0
+    end_location:
+      row: 35
+      column: 0
+
--- a/src/isort/track.rs
+++ b/src/isort/track.rs
@@ -1,3 +1,5 @@
+use std::path::Path;
+
 use rustpython_ast::{
    Alias, Arg, Arguments, Boolop, Cmpop, Comprehension, Constant, Excepthandler,
    ExcepthandlerKind, Expr, ExprContext, Keyword, MatchCase, Operator, Pattern, Stmt, StmtKind,
@@ -20,16 +22,18 @@ pub struct Block<'a> {
 }

 pub struct ImportTracker<'a> {
-    blocks: Vec<Block<'a>>,
    directives: &'a IsortDirectives,
+    pyi: bool,
+    blocks: Vec<Block<'a>>,
    split_index: usize,
    nested: bool,
 }

 impl<'a> ImportTracker<'a> {
-    pub fn new(directives: &'a IsortDirectives) -> Self {
+    pub fn new(directives: &'a IsortDirectives, path: &'a Path) -> Self {
        Self {
            directives,
+            pyi: path.extension().map_or(false, |ext| ext == "pyi"),
            blocks: vec![Block::default()],
            split_index: 0,
            nested: false,
@@ -41,6 +45,34 @@ impl<'a> ImportTracker<'a> {
        self.blocks[index].imports.push(stmt);
    }

+    fn trailer_for(&self, stmt: &'a Stmt) -> Option<Trailer> {
+        if self.pyi {
+            // Black treats interface files differently, limiting to one newline
+            // (`Trailing::Sibling`), and avoiding inserting any newlines in nested function
+            // blocks.
+            if self.nested
+                && matches!(
+                    stmt.node,
+                    StmtKind::FunctionDef { .. } | StmtKind::AsyncFunctionDef { .. }
+                )
+            {
+                None
+            } else {
+                Some(Trailer::Sibling)
+            }
+        } else if self.nested {
+            Some(Trailer::Sibling)
+        } else {
+            Some(match &stmt.node {
+                StmtKind::FunctionDef { .. } | StmtKind::AsyncFunctionDef { .. } => {
+                    Trailer::FunctionDef
+                }
+                StmtKind::ClassDef { .. } => Trailer::ClassDef,
+                _ => Trailer::Sibling,
+            })
+        }
+    }
+
    fn finalize(&mut self, trailer: Option<Trailer>) {
        let index = self.blocks.len() - 1;
        if !self.blocks[index].imports.is_empty() {
@@ -62,17 +94,7 @@ where
        // Track manual splits.
        while self.split_index < self.directives.splits.len() {
            if stmt.location.row() >= self.directives.splits[self.split_index] {
-                self.finalize(Some(if self.nested {
-                    Trailer::Sibling
-                } else {
-                    match &stmt.node {
-                        StmtKind::FunctionDef { .. } | StmtKind::AsyncFunctionDef { .. } => {
-                            Trailer::FunctionDef
-                        }
-                        StmtKind::ClassDef { .. } => Trailer::ClassDef,
-                        _ => Trailer::Sibling,
-                    }
-                }));
+                self.finalize(self.trailer_for(stmt));
                self.split_index += 1;
            } else {
                break;
@@ -87,17 +109,7 @@ where
        {
            self.track_import(stmt);
        } else {
-            self.finalize(Some(if self.nested {
-                Trailer::Sibling
-            } else {
-                match &stmt.node {
-                    StmtKind::FunctionDef { .. } | StmtKind::AsyncFunctionDef { .. } => {
-                        Trailer::FunctionDef
-                    }
-                    StmtKind::ClassDef { .. } => Trailer::ClassDef,
-                    _ => Trailer::Sibling,
-                }
-            }));
+            self.finalize(self.trailer_for(stmt));
        }

        // Track scope.
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -53,7 +53,9 @@ mod flake8_import_conventions;
 mod flake8_print;
 pub mod flake8_quotes;
 mod flake8_return;
+mod flake8_simplify;
 pub mod flake8_tidy_imports;
+mod flake8_unused_arguments;
 pub mod fs;
 mod isort;
 mod lex;
--- a/src/linter.rs
+++ b/src/linter.rs
@@ -92,6 +92,7 @@ pub(crate) fn check_path(
                        &directives.isort,
                        settings,
                        autofix,
+                        path,
                    ));
                }
            }
@@ -133,7 +134,7 @@ pub(crate) fn check_path(
    Ok(checks)
 }

-const MAX_ITERATIONS: usize = 1;
+const MAX_ITERATIONS: usize = 100;

 /// Lint the source code at the given `Path`.
 pub fn lint_path(
--- a/src/main.rs
+++ b/src/main.rs
@@ -19,7 +19,7 @@ use std::time::Instant;

 use ::ruff::autofix::fixer;
 use ::ruff::checks::{CheckCode, CheckKind};
-use ::ruff::cli::{collect_per_file_ignores, extract_log_level, Cli};
+use ::ruff::cli::{extract_log_level, Cli};
 use ::ruff::fs::iter_python_files;
 use ::ruff::linter::{add_noqa_to_path, autoformat_path, lint_path, lint_stdin, Diagnostics};
 use ::ruff::logging::{set_up_logging, LogLevel};
@@ -199,8 +199,7 @@ fn autoformat(files: &[PathBuf], settings: &Settings) -> usize {

 fn inner_main() -> Result<ExitCode> {
    // Extract command-line arguments.
-    let cli = Cli::parse();
-    let fix = cli.fix();
+    let (cli, overrides) = Cli::parse().partition();
    let log_level = extract_log_level(&cli);
    set_up_logging(&log_level)?;

@@ -220,54 +219,7 @@ fn inner_main() -> Result<ExitCode> {
    // Reconcile configuration from pyproject.toml and command-line arguments.
    let mut configuration =
        Configuration::from_pyproject(pyproject.as_ref(), project_root.as_ref())?;
-    if !cli.exclude.is_empty() {
-        configuration.exclude = cli.exclude;
-    }
-    if !cli.extend_exclude.is_empty() {
-        configuration.extend_exclude = cli.extend_exclude;
-    }
-    if !cli.per_file_ignores.is_empty() {
-        configuration.per_file_ignores = collect_per_file_ignores(cli.per_file_ignores);
-    }
-    if !cli.select.is_empty() {
-        configuration.select = cli.select;
-    }
-    if !cli.extend_select.is_empty() {
-        configuration.extend_select = cli.extend_select;
-    }
-    if !cli.ignore.is_empty() {
-        configuration.ignore = cli.ignore;
-    }
-    if !cli.extend_ignore.is_empty() {
-        configuration.extend_ignore = cli.extend_ignore;
-    }
-    if !cli.fixable.is_empty() {
-        configuration.fixable = cli.fixable;
-    }
-    if !cli.unfixable.is_empty() {
-        configuration.unfixable = cli.unfixable;
-    }
-    if let Some(format) = cli.format {
-        configuration.format = format;
-    }
-    if let Some(line_length) = cli.line_length {
-        configuration.line_length = line_length;
-    }
-    if let Some(max_complexity) = cli.max_complexity {
-        configuration.mccabe.max_complexity = max_complexity;
-    }
-    if let Some(target_version) = cli.target_version {
-        configuration.target_version = target_version;
-    }
-    if let Some(dummy_variable_rgx) = cli.dummy_variable_rgx {
-        configuration.dummy_variable_rgx = dummy_variable_rgx;
-    }
-    if let Some(fix) = fix {
-        configuration.fix = fix;
-    }
-    if cli.show_source {
-        configuration.show_source = true;
-    }
+    configuration.merge(overrides);

    if cli.show_settings && cli.show_files {
        eprintln!("Error: specify --show-settings or show-files (not both).");
@@ -278,14 +230,16 @@ fn inner_main() -> Result<ExitCode> {
        return Ok(ExitCode::SUCCESS);
    }

-    // Extract settings for internal use.
-    let autofix = if configuration.fix {
+    // TODO(charlie): Included in `pyproject.toml`, but not inherited.
+    let fix = if configuration.fix {
        fixer::Mode::Apply
    } else if matches!(configuration.format, SerializationFormat::Json) {
        fixer::Mode::Generate
    } else {
        fixer::Mode::None
    };
+    let format = configuration.format;
+
    let settings = Settings::from_configuration(configuration, project_root.as_ref())?;

    // Now that we've inferred the appropriate log level, add some debug
@@ -300,7 +254,7 @@ fn inner_main() -> Result<ExitCode> {
    };

    if let Some(code) = cli.explain {
-        commands::explain(&code, settings.format)?;
+        commands::explain(&code, format)?;
        return Ok(ExitCode::SUCCESS);
    }

@@ -316,9 +270,9 @@ fn inner_main() -> Result<ExitCode> {
        cache_enabled = false;
    }

-    let printer = Printer::new(&settings.format, &log_level);
+    let printer = Printer::new(&format, &log_level);
    if cli.watch {
-        if matches!(autofix, fixer::Mode::Generate | fixer::Mode::Apply) {
+        if matches!(fix, fixer::Mode::Generate | fixer::Mode::Apply) {
            eprintln!("Warning: --fix is not enabled in watch mode.");
        }
        if cli.add_noqa {
@@ -327,7 +281,7 @@ fn inner_main() -> Result<ExitCode> {
        if cli.autoformat {
            eprintln!("Warning: --autoformat is not enabled in watch mode.");
        }
-        if settings.format != SerializationFormat::Text {
+        if format != SerializationFormat::Text {
            eprintln!("Warning: --format 'text' is used in watch mode.");
        }

@@ -383,16 +337,16 @@ fn inner_main() -> Result<ExitCode> {
        let diagnostics = if is_stdin {
            let filename = cli.stdin_filename.unwrap_or_else(|| "-".to_string());
            let path = Path::new(&filename);
-            run_once_stdin(&settings, path, &autofix)?
+            run_once_stdin(&settings, path, &fix)?
        } else {
-            run_once(&cli.files, &settings, cache_enabled, &autofix)
+            run_once(&cli.files, &settings, cache_enabled, &fix)
        };

        // Always try to print violations (the printer itself may suppress output),
        // unless we're writing fixes via stdin (in which case, the transformed
        // source code goes to stdout).
-        if !(is_stdin && matches!(autofix, fixer::Mode::Apply)) {
-            printer.write_once(&diagnostics)?;
+        if !(is_stdin && matches!(fix, fixer::Mode::Apply)) {
+            printer.write_once(&diagnostics, &fix)?;
        }

        // Check for updates if we're in a non-silent log level.
--- a/src/noqa.rs
+++ b/src/noqa.rs
@@ -1,4 +1,3 @@
-use std::collections::{BTreeMap, BTreeSet};
 use std::fs;
 use std::path::Path;

@@ -7,8 +6,9 @@ use itertools::Itertools;
 use nohash_hasher::IntMap;
 use once_cell::sync::Lazy;
 use regex::Regex;
+use rustc_hash::{FxHashMap, FxHashSet};

-use crate::checks::{Check, CheckCode, REDIRECTS};
+use crate::checks::{Check, CheckCode, CODE_REDIRECTS};

 static NO_QA_LINE_REGEX: Lazy<Regex> = Lazy::new(|| {
    Regex::new(
@@ -70,7 +70,7 @@ pub fn extract_noqa_directive(line: &str) -> Directive {
 pub fn includes(needle: &CheckCode, haystack: &[&str]) -> bool {
    let needle: &str = needle.as_ref();
    haystack.iter().any(|candidate| {
-        if let Some(candidate) = REDIRECTS.get(candidate) {
+        if let Some(candidate) = CODE_REDIRECTS.get(candidate) {
            needle == candidate.as_ref()
        } else {
            &needle == candidate
@@ -83,7 +83,7 @@ pub fn add_noqa(
    checks: &[Check],
    contents: &str,
    noqa_line_for: &IntMap<usize, usize>,
-    external: &BTreeSet<String>,
+    external: &FxHashSet<String>,
 ) -> Result<usize> {
    let (count, output) = add_noqa_inner(checks, contents, noqa_line_for, external);
    fs::write(path, output)?;
@@ -94,16 +94,16 @@ fn add_noqa_inner(
    checks: &[Check],
    contents: &str,
    noqa_line_for: &IntMap<usize, usize>,
-    external: &BTreeSet<String>,
+    external: &FxHashSet<String>,
 ) -> (usize, String) {
-    let mut matches_by_line: BTreeMap<usize, BTreeSet<&CheckCode>> = BTreeMap::new();
+    let mut matches_by_line: FxHashMap<usize, FxHashSet<&CheckCode>> = FxHashMap::default();
    for (lineno, line) in contents.lines().enumerate() {
        // If we hit an exemption for the entire file, bail.
        if is_file_exempt(line) {
            return (0, contents.to_string());
        }

-        let mut codes: BTreeSet<&CheckCode> = BTreeSet::new();
+        let mut codes: FxHashSet<&CheckCode> = FxHashSet::default();
        for check in checks {
            if check.location.row() == lineno + 1 {
                codes.insert(check.kind.code());
@@ -117,7 +117,7 @@ fn add_noqa_inner(

        if !codes.is_empty() {
            let matches = matches_by_line.entry(noqa_lineno).or_default();
-            matches.append(&mut codes);
+            matches.extend(codes);
        }
    }

@@ -199,9 +199,9 @@ fn add_noqa_inner(

 #[cfg(test)]
 mod tests {
-    use std::collections::BTreeSet;

    use nohash_hasher::IntMap;
+    use rustc_hash::FxHashSet;
    use rustpython_parser::ast::Location;

    use crate::ast::types::Range;
@@ -227,7 +227,7 @@ mod tests {
        let checks = vec![];
        let contents = "x = 1";
        let noqa_line_for = IntMap::default();
-        let external = BTreeSet::default();
+        let external = FxHashSet::default();
        let (count, output) = add_noqa_inner(&checks, contents, &noqa_line_for, &external);
        assert_eq!(count, 0);
        assert_eq!(output.trim(), contents.trim());
@@ -241,7 +241,7 @@ mod tests {
        )];
        let contents = "x = 1";
        let noqa_line_for = IntMap::default();
-        let external = BTreeSet::default();
+        let external = FxHashSet::default();
        let (count, output) = add_noqa_inner(&checks, contents, &noqa_line_for, &external);
        assert_eq!(count, 1);
        assert_eq!(output.trim(), "x = 1  # noqa: F841".trim());
@@ -264,7 +264,7 @@ mod tests {
        ];
        let contents = "x = 1  # noqa: E741";
        let noqa_line_for = IntMap::default();
-        let external = BTreeSet::default();
+        let external = FxHashSet::default();
        let (count, output) = add_noqa_inner(&checks, contents, &noqa_line_for, &external);
        assert_eq!(count, 1);
        assert_eq!(output.trim(), "x = 1  # noqa: E741, F841".trim());
@@ -287,7 +287,7 @@ mod tests {
        ];
        let contents = "x = 1  # noqa";
        let noqa_line_for = IntMap::default();
-        let external = BTreeSet::default();
+        let external = FxHashSet::default();
        let (count, output) = add_noqa_inner(&checks, contents, &noqa_line_for, &external);
        assert_eq!(count, 1);
        assert_eq!(output.trim(), "x = 1  # noqa: E741, F841".trim());
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Charlie Marsh	9161b866b5	Bump version to 0.0.176	2022-12-11 10:19:50 -05:00
Reiner Gerecke	38141a6f14	Check for outdated auto-generated files in CI (#1192 )	2022-12-11 10:18:57 -05:00
Charlie Marsh	aa5402fc0e	Add flake8-simplify to flake8-to-ruff	2022-12-11 10:10:46 -05:00
Charlie Marsh	99f077aa4e	Add missing hash in README comment	2022-12-11 10:05:32 -05:00
Reiner Gerecke	7f25d1ec70	Implement SIM118 (key in dict) of flake8-simplify (#1195 )	2022-12-11 10:05:11 -05:00
Charlie Marsh	360b033e04	Avoid F821 false positive on annotated global (#1196 )	2022-12-11 10:04:06 -05:00
Reiner Gerecke	247dcc9f9c	Mark C413 as fixable (#1191 )	2022-12-11 09:07:51 -05:00
Charlie Marsh	c86e52193c	Bump version to 0.0.175	2022-12-10 21:23:19 -05:00
Harutaka Kawamura	efdc4e801d	Upgrade RustPython to fix end location of implicitly concatenated strings (#1187 )	2022-12-10 19:16:01 -05:00
Charlie Marsh	f8f2eeed35	Enable --no-show-source for consistency (#1189 )	2022-12-10 19:09:49 -05:00
Charlie Marsh	8fa414b67e	Move configuration-CLI resolution into dedicated methods (#1188 )	2022-12-10 19:07:38 -05:00
Charlie Marsh	484d7a30bd	Add TODO around nested globals	2022-12-10 17:44:08 -05:00
Charlie Marsh	fb681c614a	Move string formatting checks to plugins (#1185 )	2022-12-10 16:43:21 -05:00
Reiner Gerecke	06ed125771	Add autofix for F504 and F522 (#1184 )	2022-12-10 16:33:09 -05:00
Charlie Marsh	74668915b0	Remove serialization format from Settings struct (#1183 )	2022-12-10 13:38:59 -05:00
Charlie Marsh	6da3de25ba	Add jupyter_server to README (#1182 )	2022-12-10 12:10:27 -05:00
Charlie Marsh	63b3e00c97	Bump version to 0.0.174	2022-12-10 12:08:48 -05:00
Charlie Marsh	39440aa274	Create function and lambda scopes eagerly (#1181 )	2022-12-10 12:08:33 -05:00
Charlie Marsh	add96d3dc5	Implement E0117 (nonlocal-without-binding) (#1180 )	2022-12-10 11:41:57 -05:00
Charlie Marsh	6f8e0224d0	Implement W0602 (global-variable-not-assigned) (#1179 )	2022-12-10 11:33:24 -05:00
Charlie Marsh	b8bbafd85b	Flag global usages prior to `global` declarations (#1178 )	2022-12-10 11:19:24 -05:00
Charlie Marsh	40b54d3e8c	Ignore imports in class scopes (#1176 )	2022-12-10 10:23:33 -05:00
Charlie Marsh	2b44941d63	Add pacman instructions to README (#1175 )	2022-12-10 10:00:01 -05:00
Charlie Marsh	257bd7f1d7	Bump version to 0.0.173	2022-12-09 23:23:12 -05:00
Charlie Marsh	5728dceef0	Add note around redefinitions	2022-12-09 23:18:51 -05:00
Charlie Marsh	6739602806	Mark redefined-but-unused imports as unused regardless of scope (#1173 )	2022-12-09 23:17:33 -05:00
Charlie Marsh	305326f7d7	Remove some string clones from docstring helpers (#1172 )	2022-12-09 22:30:34 -05:00
Charlie Marsh	69866f5461	Extract docstring exactly once (#1171 )	2022-12-09 22:21:16 -05:00
Charlie Marsh	41ca29c4f4	Add TODO in redefined_by_function	2022-12-09 21:19:57 -05:00
Charlie Marsh	b35a804f9d	Bump version to 0.0.172	2022-12-09 17:47:34 -05:00
Charlie Marsh	e594ed6528	Implement D301 (backslash checks) (#1169 )	2022-12-09 17:44:18 -05:00
Charlie Marsh	197645d90d	Always use raw docstrings for pydocstyle rules (#1167 )	2022-12-09 17:31:04 -05:00
Charlie Marsh	26d3ff5a3a	Add pyflakes test suite for annotations (#1166 )	2022-12-09 16:28:07 -05:00
Charlie Marsh	0dacf61153	Implement F842 (UnusedAnnotation) (#1165 )	2022-12-09 12:42:03 -05:00
Charlie Marsh	a6251360b7	Avoid RET false-positives for usages in f-strings (#1163 )	2022-12-09 12:28:09 -05:00
Charlie Marsh	2965e2561d	Clarify combination of combine-as-imports and force-wrap-aliases (#1162 )	2022-12-09 12:20:15 -05:00
Charlie Marsh	a19050b8a4	Update README.md	2022-12-08 23:39:01 -05:00
Charlie Marsh	dfd6225d85	Bump version to 0.0.171	2022-12-08 23:18:48 -05:00
Charlie Marsh	a0a6327fae	Only allowlist noqa et al at the start of a comment (#1157 )	2022-12-08 23:10:36 -05:00
Charlie Marsh	db815a565f	Run release job on release: published event (#1156 )	2022-12-08 23:05:28 -05:00
Charlie Marsh	3bacdafd1c	Improve some __all__ handling cases (#1155 )	2022-12-08 23:03:23 -05:00
Charlie Marsh	6403e3630d	Fix flaky unused import test	2022-12-08 22:51:13 -05:00
Charlie Marsh	229eab6f42	Improve some behavior around global handling (#1154 )	2022-12-08 22:47:19 -05:00
Charlie Marsh	e33582fb0e	Add pyflakes import test suite (#1151 )	2022-12-08 22:23:37 -05:00
Charlie Marsh	aaeab0ecf1	Implement F811 (`RedefinedWhileUnused`) (#1137 )	2022-12-08 21:31:08 -05:00
Charlie Marsh	f9a16d9c44	Fix GitHub link	2022-12-08 20:54:54 -05:00
Charlie Marsh	2aa884eb9b	Re-implement the entire test_undefined_names.py test suite (#1150 )	2022-12-08 20:53:01 -05:00
Charlie Marsh	84fa64d98c	Move bindings to an arena (#1147 )	2022-12-08 19:48:00 -05:00
Charlie Marsh	c1b1ac069e	Include else block in break detection (#1143 )	2022-12-08 11:53:31 -05:00
Charlie Marsh	a710e35ebc	Bump version to 0.0.170	2022-12-08 11:36:24 -05:00
Charlie Marsh	49df43bb78	Use single newlines in .pyi import sorting (#1142 )	2022-12-08 11:34:41 -05:00
Charlie Marsh	e338d9acbe	Remove 'consider' language from check messages (#1135 )	2022-12-07 20:10:36 -05:00
Charlie Marsh	5c8655f479	Bump ruff_macros to 0.0.169	2022-12-07 19:10:16 -05:00
Charlie Marsh	60987888a2	Re-increase max iterations to 100	2022-12-07 19:10:03 -05:00
Charlie Marsh	a81581c781	Bump ruff_macros to 0.0.168	2022-12-07 19:08:18 -05:00
Charlie Marsh	3152dd7a8e	Don't prompt users to --fix if they ran with --fix (#1133 )	2022-12-07 19:07:51 -05:00
Charlie Marsh	528416f07a	Rename I252 to TID252; add redirects for all renamed codes (#1129 )	2022-12-07 15:12:22 -05:00
Charlie Marsh	4405a6a903	Bump version to 0.0.168	2022-12-07 13:18:40 -05:00
Charlie Marsh	35fa2a3c32	Convert more BTree usages to Fx (#1112 )	2022-12-07 12:21:12 -05:00
Charlie Marsh	bb67fbb73a	Implement unused argument detection (`ARG`) (#1126 ) Detect unused arguments	2022-12-07 12:15:41 -05:00