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
60 changed files with 2361 additions and 1184 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/.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.172
+    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.172-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.172"
+version = "0.0.176"
 dependencies = [
 "annotate-snippets 0.9.1",
 "anyhow",
@@ -1874,7 +1874,7 @@ dependencies = [

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

 [[package]]
 name = "ruff_macros"
-version = "0.0.172"
+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.172"
+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.172", 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/25
+++ b/25
@@ -438,6 +438,31 @@ are:
    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).

@@ -89,6 +90,7 @@ 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-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)
@@ -120,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:
@@ -147,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.172
+    rev: v0.0.176
    hooks:
      - id: ruff
 ```
@@ -362,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.

@@ -412,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 |  |
@@ -709,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)()`) | 🛠 |
@@ -764,6 +772,14 @@ 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-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.
@@ -809,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 | 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)

--- 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.172"
+version = "0.0.176"
 dependencies = [
 "anyhow",
 "clap",
@@ -1975,7 +1975,7 @@ dependencies = [

 [[package]]
 name = "ruff"
-version = "0.0.172"
+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.172-dev.0"
+version = "0.0.176-dev.0"
 edition = "2021"

 [lib]
--- 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],
@@ -397,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/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/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/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/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/ruff_dev/Cargo.toml
+++ b/ruff_dev/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "ruff_dev"
-version = "0.0.172"
+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_macros/Cargo.toml
+++ b/ruff_macros/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "ruff_macros"
-version = "0.0.172"
+version = "0.0.176"
 edition = "2021"

 [lib]
--- a/src/ast/operations.rs
+++ b/src/ast/operations.rs
@@ -1,9 +1,12 @@
+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::{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, bindings: &[Binding]) -> Vec<String> {
@@ -69,6 +72,38 @@ pub fn extract_all_names(stmt: &Stmt, scope: &Scope, bindings: &[Binding]) -> Ve
    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
@@ -32,23 +32,29 @@ impl Range {

 #[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 globals: FxHashMap<&'a str, &'a Stmt>,
 }

 #[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(Debug)]
@@ -73,7 +79,11 @@ pub struct Scope<'a> {
    pub kind: ScopeKind<'a>,
    pub import_starred: bool,
    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> {
@@ -84,6 +94,7 @@ impl<'a> Scope<'a> {
            import_starred: false,
            uses_locals: false,
            values: FxHashMap::default(),
+            overridden: Vec::new(),
        }
    }
 }
@@ -117,8 +128,6 @@ pub struct Binding<'a> {
    /// Tuple of (scope index, range) indicating the scope and range at which
    /// the binding was last used.
    pub used: Option<(usize, Range)>,
-    /// A list of pointers to `Binding` instances that redefined this binding.
-    pub redefined: Vec<usize>,
 }

 // Pyflakes defines the following binding hierarchy (via inheritance):
--- 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/checks.rs
+++ b/src/checks.rs
@@ -99,12 +99,15 @@ pub enum CheckCode {
    PLC0414,
    PLC2201,
    PLC3002,
+    PLE0117,
+    PLE0118,
    PLE1142,
    PLR0206,
    PLR0402,
    PLR1701,
    PLR1722,
    PLW0120,
+    PLW0602,
    // flake8-builtins
    A001,
    A002,
@@ -203,6 +206,8 @@ pub enum CheckCode {
    YTT301,
    YTT302,
    YTT303,
+    // flake8-simplify
+    SIM118,
    // pyupgrade
    UP001,
    UP003,
@@ -334,6 +339,7 @@ pub enum CheckCategory {
    Flake8Print,
    Flake8Quotes,
    Flake8Return,
+    Flake8Simplify,
    Flake8TidyImports,
    Flake8UnusedArguments,
    Eradicate,
@@ -374,6 +380,7 @@ 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",
@@ -403,6 +410,7 @@ impl CheckCategory {
            CheckCategory::Flake8Print => vec![CheckCodePrefix::T20],
            CheckCategory::Flake8Quotes => vec![CheckCodePrefix::Q],
            CheckCategory::Flake8Return => vec![CheckCodePrefix::RET],
+            CheckCategory::Flake8Simplify => vec![CheckCodePrefix::SIM],
            CheckCategory::Flake8TidyImports => vec![CheckCodePrefix::TID],
            CheckCategory::Flake8UnusedArguments => vec![CheckCodePrefix::ARG],
            CheckCategory::Isort => vec![CheckCodePrefix::I],
@@ -478,6 +486,10 @@ 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,
@@ -635,15 +647,18 @@ pub enum CheckKind {
    UnusedVariable(String),
    YieldOutsideFunction(DeferralKeyword),
    // pylint
-    ConsiderMergingIsinstance(String, Vec<String>),
-    UselessImportAlias,
-    MisplacedComparisonConstant(String),
-    UnnecessaryDirectLambdaCall,
-    PropertyWithParameters,
-    ConsiderUsingFromImport(String, String),
    AwaitOutsideAsync,
-    UselessElseOnLoop,
+    ConsiderMergingIsinstance(String, Vec<String>),
+    ConsiderUsingFromImport(String, String),
+    GlobalVariableNotAssigned(String),
+    MisplacedComparisonConstant(String),
+    NonlocalWithoutBinding(String),
+    PropertyWithParameters,
+    UnnecessaryDirectLambdaCall,
    UseSysExit(String),
+    UsedPriorGlobalDeclaration(String, usize),
+    UselessElseOnLoop,
+    UselessImportAlias,
    // flake8-builtins
    BuiltinVariableShadowing(String),
    BuiltinArgumentShadowing(String),
@@ -740,6 +755,8 @@ pub enum CheckKind {
    SysVersion0Referenced,
    SysVersionCmpStr10,
    SysVersionSlice1Referenced,
+    // flake8-simplify
+    KeyInDict(String, String),
    // pyupgrade
    TypeOfPrimitive(Primitive),
    UselessMetaclassType,
@@ -950,6 +967,8 @@ impl CheckCode {
            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())
@@ -960,6 +979,7 @@ impl CheckCode {
            }
            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()),
@@ -1073,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),
@@ -1402,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,
@@ -1430,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,
@@ -1530,15 +1556,18 @@ impl CheckKind {
            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::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,
@@ -1635,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,
@@ -1947,6 +1978,9 @@ impl CheckKind {
            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."
                .to_string(),
@@ -1956,6 +1990,12 @@ impl CheckKind {
            CheckKind::ConsiderUsingFromImport(module, 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()
            }
@@ -2292,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())
@@ -2636,6 +2680,7 @@ impl CheckKind {
                | CheckKind::ImplicitReturn
                | CheckKind::ImplicitReturnValue
                | CheckKind::IsLiteral
+                | CheckKind::KeyInDict(..)
                | CheckKind::MisplacedComparisonConstant(..)
                | CheckKind::NewLineAfterLastParagraph
                | CheckKind::NewLineAfterSectionName(..)
@@ -2651,6 +2696,7 @@ impl CheckKind {
                | CheckKind::NotIsTest
                | CheckKind::OneBlankLineAfterClass(..)
                | CheckKind::OneBlankLineBeforeClass(..)
+                | CheckKind::PercentFormatExtraNamedArguments(..)
                | CheckKind::PEP3120UnnecessaryCodingComment
                | CheckKind::PPrintFound
                | CheckKind::PrintFound
@@ -2663,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
--- a/src/checks_gen.rs
+++ b/src/checks_gen.rs
@@ -315,6 +315,11 @@ pub enum CheckCodePrefix {
    PLC300,
    PLC3002,
    PLE,
+    PLE0,
+    PLE01,
+    PLE011,
+    PLE0117,
+    PLE0118,
    PLE1,
    PLE11,
    PLE114,
@@ -338,6 +343,9 @@ pub enum CheckCodePrefix {
    PLW01,
    PLW012,
    PLW0120,
+    PLW06,
+    PLW060,
+    PLW0602,
    Q,
    Q0,
    Q00,
@@ -374,6 +382,10 @@ pub enum CheckCodePrefix {
    S105,
    S106,
    S107,
+    SIM,
+    SIM1,
+    SIM11,
+    SIM118,
    T,
    T1,
    T10,
@@ -1343,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],
@@ -1367,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,
@@ -1476,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],
@@ -2118,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,
@@ -2141,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,
@@ -2177,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,
@@ -2277,6 +2315,7 @@ pub const CATEGORIES: &[CheckCodePrefix] = &[
    CheckCodePrefix::RET,
    CheckCodePrefix::RUF,
    CheckCodePrefix::S,
+    CheckCodePrefix::SIM,
    CheckCodePrefix::T,
    CheckCodePrefix::TID,
    CheckCodePrefix::UP,
--- 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/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/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/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/lib.rs
+++ b/src/lib.rs
@@ -53,6 +53,7 @@ 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;
--- 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, &autofix)?;
+        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/pycodestyle/plugins.rs
+++ b/src/pycodestyle/plugins.rs
@@ -298,11 +298,11 @@ pub fn do_not_assign_lambda(checker: &mut Checker, target: &Expr, value: &Expr,
                {
                    match function(id, args, body) {
                        Ok(content) => {
-                            let indentation =
-                                &leading_space(&checker.locator.slice_source_code_range(&Range {
-                                    location: Location::new(stmt.location.row(), 0),
-                                    end_location: Location::new(stmt.location.row() + 1, 0),
-                                }));
+                            let first_line = checker.locator.slice_source_code_range(&Range {
+                                location: Location::new(stmt.location.row(), 0),
+                                end_location: Location::new(stmt.location.row() + 1, 0),
+                            });
+                            let indentation = &leading_space(&first_line);
                            let mut indented = String::new();
                            for (idx, line) in content.lines().enumerate() {
                                if idx == 0 {
--- a/src/pydocstyle/helpers.rs
+++ b/src/pydocstyle/helpers.rs
@@ -1,8 +1,4 @@
-use rustpython_ast::Expr;
-
-use crate::ast::types::Range;
 use crate::docstrings::constants;
-use crate::SourceCodeLocator;

 /// Strip the leading and trailing quotes from a docstring.
 pub fn raw_contents(contents: &str) -> &str {
@@ -20,12 +16,8 @@ pub fn raw_contents(contents: &str) -> &str {
 }

 /// Return the leading quote string for a docstring (e.g., `"""`).
-pub fn leading_quote<'a>(docstring: &Expr, locator: &'a SourceCodeLocator) -> Option<&'a str> {
-    if let Some(first_line) = locator
-        .slice_source_code_range(&Range::from_located(docstring))
-        .lines()
-        .next()
-    {
+pub fn leading_quote(content: &str) -> Option<&str> {
+    if let Some(first_line) = content.lines().next() {
        for pattern in constants::TRIPLE_QUOTE_PREFIXES
            .iter()
            .chain(constants::SINGLE_QUOTE_PREFIXES)
--- a/src/pydocstyle/mod.rs
+++ b/src/pydocstyle/mod.rs
@@ -1,4 +1,4 @@
-mod helpers;
+pub mod helpers;
 pub mod plugins;

 #[cfg(test)]
--- a/src/pydocstyle/plugins.rs
+++ b/src/pydocstyle/plugins.rs
--- a/src/pyflakes/checks.rs
+++ b/src/pyflakes/checks.rs
@@ -2,348 +2,12 @@ use std::string::ToString;

 use regex::Regex;
 use rustc_hash::FxHashSet;
-use rustpython_ast::{Keyword, KeywordData};
 use rustpython_parser::ast::{
    Arg, Arguments, Constant, Excepthandler, ExcepthandlerKind, Expr, ExprKind, Stmt, StmtKind,
 };

 use crate::ast::types::{Binding, BindingKind, Range, Scope, ScopeKind};
 use crate::checks::{Check, CheckKind};
-use crate::pyflakes::cformat::CFormatSummary;
-use crate::pyflakes::format::FormatSummary;
-
-fn has_star_star_kwargs(keywords: &[Keyword]) -> bool {
-    keywords.iter().any(|k| {
-        let KeywordData { arg, .. } = &k.node;
-        arg.is_none()
-    })
-}
-
-fn has_star_args(args: &[Expr]) -> bool {
-    args.iter()
-        .any(|a| matches!(&a.node, ExprKind::Starred { .. }))
-}
-
-/// F502
-pub(crate) fn percent_format_expected_mapping(
-    summary: &CFormatSummary,
-    right: &Expr,
-    location: Range,
-) -> Option<Check> {
-    if summary.keywords.is_empty() {
-        None
-    } else {
-        // Tuple, List, Set (+comprehensions)
-        match right.node {
-            ExprKind::List { .. }
-            | ExprKind::Tuple { .. }
-            | ExprKind::Set { .. }
-            | ExprKind::ListComp { .. }
-            | ExprKind::SetComp { .. }
-            | ExprKind::GeneratorExp { .. } => Some(Check::new(
-                CheckKind::PercentFormatExpectedMapping,
-                location,
-            )),
-            _ => None,
-        }
-    }
-}
-
-/// F503
-pub(crate) fn percent_format_expected_sequence(
-    summary: &CFormatSummary,
-    right: &Expr,
-    location: Range,
-) -> Option<Check> {
-    if summary.num_positional <= 1 {
-        None
-    } else {
-        match right.node {
-            ExprKind::Dict { .. } | ExprKind::DictComp { .. } => Some(Check::new(
-                CheckKind::PercentFormatExpectedSequence,
-                location,
-            )),
-            _ => None,
-        }
-    }
-}
-
-/// F504
-pub(crate) fn percent_format_extra_named_arguments(
-    summary: &CFormatSummary,
-    right: &Expr,
-    location: Range,
-) -> Option<Check> {
-    if summary.num_positional > 0 {
-        return None;
-    }
-    let ExprKind::Dict { keys, values } = &right.node else {
-        return None;
-    };
-    if values.len() > keys.len() {
-        return None; // contains **x splat
-    }
-
-    let missing: Vec<&String> = keys
-        .iter()
-        .filter_map(|k| match &k.node {
-            // We can only check that string literals exist
-            ExprKind::Constant {
-                value: Constant::Str(value),
-                ..
-            } => {
-                if summary.keywords.contains(value) {
-                    None
-                } else {
-                    Some(value)
-                }
-            }
-            _ => None,
-        })
-        .collect();
-
-    if missing.is_empty() {
-        return None;
-    }
-
-    Some(Check::new(
-        CheckKind::PercentFormatExtraNamedArguments(missing.iter().map(|&s| s.clone()).collect()),
-        location,
-    ))
-}
-
-/// F505
-pub(crate) fn percent_format_missing_arguments(
-    summary: &CFormatSummary,
-    right: &Expr,
-    location: Range,
-) -> Option<Check> {
-    if summary.num_positional > 0 {
-        return None;
-    }
-
-    if let ExprKind::Dict { keys, values } = &right.node {
-        if values.len() > keys.len() {
-            return None; // contains **x splat
-        }
-
-        let mut keywords = FxHashSet::default();
-        for key in keys {
-            match &key.node {
-                ExprKind::Constant {
-                    value: Constant::Str(value),
-                    ..
-                } => {
-                    keywords.insert(value);
-                }
-                _ => {
-                    return None; // Dynamic keys present
-                }
-            }
-        }
-
-        let missing: Vec<&String> = summary
-            .keywords
-            .iter()
-            .filter(|k| !keywords.contains(k))
-            .collect();
-
-        if missing.is_empty() {
-            None
-        } else {
-            Some(Check::new(
-                CheckKind::PercentFormatMissingArgument(
-                    missing.iter().map(|&s| s.clone()).collect(),
-                ),
-                location,
-            ))
-        }
-    } else {
-        None
-    }
-}
-
-/// F506
-pub(crate) fn percent_format_mixed_positional_and_named(
-    summary: &CFormatSummary,
-    location: Range,
-) -> Option<Check> {
-    if summary.num_positional == 0 || summary.keywords.is_empty() {
-        None
-    } else {
-        Some(Check::new(
-            CheckKind::PercentFormatMixedPositionalAndNamed,
-            location,
-        ))
-    }
-}
-
-/// F507
-pub(crate) fn percent_format_positional_count_mismatch(
-    summary: &CFormatSummary,
-    right: &Expr,
-    location: Range,
-) -> Option<Check> {
-    if !summary.keywords.is_empty() {
-        return None;
-    }
-
-    match &right.node {
-        ExprKind::List { elts, .. } | ExprKind::Tuple { elts, .. } | ExprKind::Set { elts, .. } => {
-            let mut found = 0;
-            for elt in elts {
-                if let ExprKind::Starred { .. } = &elt.node {
-                    return None;
-                }
-                found += 1;
-            }
-
-            if found == summary.num_positional {
-                None
-            } else {
-                Some(Check::new(
-                    CheckKind::PercentFormatPositionalCountMismatch(summary.num_positional, found),
-                    location,
-                ))
-            }
-        }
-        _ => None,
-    }
-}
-
-/// F508
-pub(crate) fn percent_format_star_requires_sequence(
-    summary: &CFormatSummary,
-    right: &Expr,
-    location: Range,
-) -> Option<Check> {
-    if summary.starred {
-        match &right.node {
-            ExprKind::Dict { .. } | ExprKind::DictComp { .. } => Some(Check::new(
-                CheckKind::PercentFormatStarRequiresSequence,
-                location,
-            )),
-            _ => None,
-        }
-    } else {
-        None
-    }
-}
-
-/// F522
-pub(crate) fn string_dot_format_extra_named_arguments(
-    summary: &FormatSummary,
-    keywords: &[Keyword],
-    location: Range,
-) -> Option<Check> {
-    if has_star_star_kwargs(keywords) {
-        return None;
-    }
-
-    let keywords = keywords.iter().filter_map(|k| {
-        let KeywordData { arg, .. } = &k.node;
-        arg.as_ref()
-    });
-
-    let missing: Vec<&String> = keywords
-        .filter(|&k| !summary.keywords.contains(k))
-        .collect();
-
-    if missing.is_empty() {
-        None
-    } else {
-        Some(Check::new(
-            CheckKind::StringDotFormatExtraNamedArguments(
-                missing.iter().map(|&s| s.clone()).collect(),
-            ),
-            location,
-        ))
-    }
-}
-
-/// F523
-pub(crate) fn string_dot_format_extra_positional_arguments(
-    summary: &FormatSummary,
-    args: &[Expr],
-    location: Range,
-) -> Option<Check> {
-    if has_star_args(args) {
-        return None;
-    }
-
-    let missing: Vec<String> = (0..args.len())
-        .filter(|i| !(summary.autos.contains(i) || summary.indexes.contains(i)))
-        .map(|i| i.to_string())
-        .collect();
-
-    if missing.is_empty() {
-        None
-    } else {
-        Some(Check::new(
-            CheckKind::StringDotFormatExtraPositionalArguments(missing),
-            location,
-        ))
-    }
-}
-
-/// F524
-pub(crate) fn string_dot_format_missing_argument(
-    summary: &FormatSummary,
-    args: &[Expr],
-    keywords: &[Keyword],
-    location: Range,
-) -> Option<Check> {
-    if has_star_args(args) || has_star_star_kwargs(keywords) {
-        return None;
-    }
-
-    let keywords: FxHashSet<_> = keywords
-        .iter()
-        .filter_map(|k| {
-            let KeywordData { arg, .. } = &k.node;
-            arg.as_ref()
-        })
-        .collect();
-
-    let missing: Vec<String> = summary
-        .autos
-        .iter()
-        .chain(summary.indexes.iter())
-        .filter(|&&i| i >= args.len())
-        .map(ToString::to_string)
-        .chain(
-            summary
-                .keywords
-                .iter()
-                .filter(|k| !keywords.contains(k))
-                .cloned(),
-        )
-        .collect();
-
-    if missing.is_empty() {
-        None
-    } else {
-        Some(Check::new(
-            CheckKind::StringDotFormatMissingArguments(missing),
-            location,
-        ))
-    }
-}
-
-/// F525
-pub(crate) fn string_dot_format_mixing_automatic(
-    summary: &FormatSummary,
-    location: Range,
-) -> Option<Check> {
-    if summary.autos.is_empty() || summary.indexes.is_empty() {
-        None
-    } else {
-        Some(Check::new(
-            CheckKind::StringDotFormatMixingAutomatic,
-            location,
-        ))
-    }
-}

 /// F631
 pub fn assert_tuple(test: &Expr, location: Range) -> Option<Check> {
--- a/src/pyflakes/fixes.rs
+++ b/src/pyflakes/fixes.rs
@@ -1,14 +1,18 @@
 use anyhow::{bail, Result};
-use libcst_native::{Codegen, CodegenState, ImportNames, SmallStatement, Statement};
-use rustpython_ast::Stmt;
+use libcst_native::{
+    Call, Codegen, CodegenState, Dict, DictElement, Expression, ImportNames, SmallStatement,
+    Statement,
+};
+use rustpython_ast::{Expr, Stmt};

 use crate::ast::types::Range;
 use crate::autofix::{helpers, Fix};
 use crate::cst::helpers::compose_module_path;
-use crate::cst::matchers::match_module;
+use crate::cst::matchers::{match_expr, match_module};
+use crate::python::string::strip_quotes_and_prefixes;
 use crate::source_code_locator::SourceCodeLocator;

-/// Generate a Fix to remove any unused imports from an `import` statement.
+/// Generate a `Fix` to remove any unused imports from an `import` statement.
 pub fn remove_unused_imports(
    locator: &SourceCodeLocator,
    unused_imports: &Vec<(&String, &Range)>,
@@ -73,3 +77,93 @@ pub fn remove_unused_imports(
        ))
    }
 }
+
+/// Generate a `Fix` to remove unused keys from format dict.
+pub fn remove_unused_format_arguments_from_dict(
+    locator: &SourceCodeLocator,
+    unused_arguments: &[&str],
+    stmt: &Expr,
+) -> Result<Fix> {
+    let module_text = locator.slice_source_code_range(&Range::from_located(stmt));
+    let mut tree = match_module(&module_text)?;
+    let mut body = match_expr(&mut tree)?;
+
+    let new_dict = {
+        let Expression::Dict(dict) = &body.value else {
+            bail!("Expected Expression::Dict")
+        };
+
+        Dict {
+            lbrace: dict.lbrace.clone(),
+            lpar: dict.lpar.clone(),
+            rbrace: dict.rbrace.clone(),
+            rpar: dict.rpar.clone(),
+            elements: dict
+                .elements
+                .iter()
+                .filter_map(|e| match e {
+                    DictElement::Simple {
+                        key: Expression::SimpleString(name),
+                        ..
+                    } if unused_arguments.contains(&strip_quotes_and_prefixes(name.value)) => None,
+                    e => Some(e.clone()),
+                })
+                .collect(),
+        }
+    };
+
+    body.value = Expression::Dict(Box::new(new_dict));
+
+    let mut state = CodegenState::default();
+    tree.codegen(&mut state);
+
+    Ok(Fix::replacement(
+        state.to_string(),
+        stmt.location,
+        stmt.end_location.unwrap(),
+    ))
+}
+
+/// Generate a `Fix` to remove unused keyword arguments from format call.
+pub fn remove_unused_keyword_arguments_from_format_call(
+    locator: &SourceCodeLocator,
+    unused_arguments: &[&str],
+    location: Range,
+) -> Result<Fix> {
+    let module_text = locator.slice_source_code_range(&location);
+    let mut tree = match_module(&module_text)?;
+    let mut body = match_expr(&mut tree)?;
+
+    let new_call = {
+        let Expression::Call(call) = &body.value else {
+            bail!("Expected Expression::Call")
+        };
+
+        Call {
+            func: call.func.clone(),
+            lpar: call.lpar.clone(),
+            rpar: call.rpar.clone(),
+            whitespace_before_args: call.whitespace_before_args.clone(),
+            whitespace_after_func: call.whitespace_after_func.clone(),
+            args: call
+                .args
+                .iter()
+                .filter_map(|e| match &e.keyword {
+                    Some(kw) if unused_arguments.contains(&kw.value) => None,
+                    _ => Some(e.clone()),
+                })
+                .collect(),
+        }
+    };
+
+    body.value = Expression::Call(Box::new(new_call));
+
+    let mut state = CodegenState::default();
+    tree.codegen(&mut state);
+
+    Ok(Fix::replacement(
+        state.to_string(),
+        location.location,
+        location.end_location,
+    ))
+}
--- a/src/pyflakes/foo.rs
+++ b/src/pyflakes/foo.rs
@@ -1 +0,0 @@
-
--- a/src/pyflakes/mod.rs
+++ b/src/pyflakes/mod.rs
@@ -1,7 +1,6 @@
 pub mod cformat;
 pub mod checks;
 pub mod fixes;
-mod foo;
 pub mod format;
 pub mod plugins;

@@ -94,6 +93,7 @@ mod tests {
    #[test_case(CheckCode::F821, Path::new("F821_3.py"); "F821_3")]
    #[test_case(CheckCode::F821, Path::new("F821_4.py"); "F821_4")]
    #[test_case(CheckCode::F821, Path::new("F821_5.py"); "F821_5")]
+    #[test_case(CheckCode::F821, Path::new("F821_6.py"); "F821_6")]
    #[test_case(CheckCode::F822, Path::new("F822.py"); "F822")]
    #[test_case(CheckCode::F823, Path::new("F823.py"); "F823")]
    #[test_case(CheckCode::F831, Path::new("F831.py"); "F831")]
@@ -405,14 +405,23 @@ mod tests {
        "#,
            &[],
        )?;
-        // Pyflakes allows this, but it causes other issues.
-        // flakes(
-        //     r#"
-        // def c(): bar
-        // def b(): global bar; bar = 1
-        // "#,
-        //     &[],
-        // )?;
+        flakes(
+            r#"
+        def c(): bar
+        def b(): global bar; bar = 1
+        "#,
+            &[],
+        )?;
+        // TODO(charlie): Extract globals recursively (such that we don't raise F821).
+        flakes(
+            r#"
+        def c(): bar
+        def d():
+            def b():
+                global bar; bar = 1
+        "#,
+            &[CheckCode::F821],
+        )?;
        Ok(())
    }

@@ -1105,11 +1114,11 @@ mod tests {
    fn aliased_import() -> Result<()> {
        flakes(
            "import fu as FU, bar as FU",
-            &[CheckCode::F811, CheckCode::F401],
+            &[CheckCode::F401, CheckCode::F811, CheckCode::F401],
        )?;
        flakes(
            "from moo import fu as FU, bar as FU",
-            &[CheckCode::F811, CheckCode::F401],
+            &[CheckCode::F401, CheckCode::F811, CheckCode::F401],
        )?;

        Ok(())
@@ -1146,9 +1155,15 @@ mod tests {

    #[test]
    fn redefined_while_unused() -> Result<()> {
-        flakes("import fu; fu = 3", &[CheckCode::F811])?;
-        flakes("import fu; fu, bar = 3", &[CheckCode::F811])?;
-        flakes("import fu; [fu, bar] = 3", &[CheckCode::F811])?;
+        flakes("import fu; fu = 3", &[CheckCode::F401, CheckCode::F811])?;
+        flakes(
+            "import fu; fu, bar = 3",
+            &[CheckCode::F401, CheckCode::F811],
+        )?;
+        flakes(
+            "import fu; [fu, bar] = 3",
+            &[CheckCode::F401, CheckCode::F811],
+        )?;

        Ok(())
    }
@@ -1165,7 +1180,7 @@ mod tests {
            import os
        os.path
        "#,
-            &[CheckCode::F811],
+            &[CheckCode::F401, CheckCode::F811],
        )?;

        Ok(())
@@ -1203,7 +1218,7 @@ mod tests {
            pass
        os.path
        "#,
-            &[CheckCode::F811],
+            &[CheckCode::F401, CheckCode::F811],
        )?;

        Ok(())
@@ -1279,7 +1294,7 @@ mod tests {
            from bb import mixer
        mixer(123)
        "#,
-            &[CheckCode::F811],
+            &[CheckCode::F401, CheckCode::F811],
        )?;

        Ok(())
@@ -1351,7 +1366,7 @@ mod tests {
        def fu():
            pass
        "#,
-            &[CheckCode::F811],
+            &[CheckCode::F401, CheckCode::F811],
        )?;

        Ok(())
@@ -1429,7 +1444,7 @@ mod tests {
        class fu:
            pass
        "#,
-            &[CheckCode::F811],
+            &[CheckCode::F401, CheckCode::F811],
        )?;

        Ok(())
@@ -1476,7 +1491,7 @@ mod tests {
        class bar:
            import fu
        "#,
-            &[CheckCode::F401],
+            &[],
        )?;

        flakes(
@@ -1486,7 +1501,7 @@ mod tests {

        fu
        "#,
-            &[CheckCode::F401, CheckCode::F821],
+            &[CheckCode::F821],
        )?;

        Ok(())
@@ -1693,7 +1708,7 @@ mod tests {
        for fu in range(2):
            pass
        "#,
-            &[CheckCode::F402],
+            &[CheckCode::F401, CheckCode::F402],
        )?;

        Ok(())
@@ -1850,7 +1865,7 @@ mod tests {
        try: pass
        except Exception as fu: pass
        "#,
-            &[CheckCode::F811, CheckCode::F841],
+            &[CheckCode::F401, CheckCode::F811, CheckCode::F841],
        )?;

        Ok(())
@@ -2091,7 +2106,7 @@ mod tests {
            def fun(self):
                fu
        "#,
-            &[CheckCode::F401, CheckCode::F821],
+            &[CheckCode::F821],
        )?;

        Ok(())
@@ -2160,7 +2175,7 @@ mod tests {
        import fu.bar, fu.bar
        fu.bar
        "#,
-            &[CheckCode::F811],
+            &[CheckCode::F401, CheckCode::F811],
        )?;
        flakes(
            r#"
@@ -2168,7 +2183,7 @@ mod tests {
        import fu.bar
        fu.bar
        "#,
-            &[CheckCode::F811],
+            &[CheckCode::F401, CheckCode::F811],
        )?;

        Ok(())
@@ -2324,7 +2339,7 @@ mod tests {
            fu
        fu
        "#,
-            &[CheckCode::F811],
+            &[CheckCode::F401, CheckCode::F811],
        )?;

        Ok(())
@@ -2337,18 +2352,17 @@ mod tests {
        Ok(())
    }

-    #[ignore]
    #[test]
    fn imported_in_class() -> Result<()> {
        // Imports in class scope can be used through self.
        flakes(
            r#"
-        class c:
+        class C:
            import i
            def __init__(self):
                self.i
        "#,
-            &[CheckCode::F401],
+            &[],
        )?;

        Ok(())
--- a/src/pyflakes/plugins/mod.rs
+++ b/src/pyflakes/plugins/mod.rs
@@ -3,9 +3,18 @@ pub use if_tuple::if_tuple;
 pub use invalid_literal_comparisons::invalid_literal_comparison;
 pub use invalid_print_syntax::invalid_print_syntax;
 pub use raise_not_implemented::raise_not_implemented;
+pub(crate) use strings::{
+    percent_format_expected_mapping, percent_format_expected_sequence,
+    percent_format_extra_named_arguments, percent_format_missing_arguments,
+    percent_format_mixed_positional_and_named, percent_format_positional_count_mismatch,
+    percent_format_star_requires_sequence, string_dot_format_extra_named_arguments,
+    string_dot_format_extra_positional_arguments, string_dot_format_missing_argument,
+    string_dot_format_mixing_automatic,
+};

 mod assert_tuple;
 mod if_tuple;
 mod invalid_literal_comparisons;
 mod invalid_print_syntax;
 mod raise_not_implemented;
+mod strings;
--- a/src/pyflakes/plugins/strings.rs
+++ b/src/pyflakes/plugins/strings.rs
@@ -0,0 +1,369 @@
+use std::string::ToString;
+
+use rustc_hash::FxHashSet;
+use rustpython_ast::{Keyword, KeywordData};
+use rustpython_parser::ast::{Constant, Expr, ExprKind};
+
+use crate::ast::types::Range;
+use crate::check_ast::Checker;
+use crate::checks::{Check, CheckKind};
+use crate::pyflakes::cformat::CFormatSummary;
+use crate::pyflakes::fixes::{
+    remove_unused_format_arguments_from_dict, remove_unused_keyword_arguments_from_format_call,
+};
+use crate::pyflakes::format::FormatSummary;
+
+fn has_star_star_kwargs(keywords: &[Keyword]) -> bool {
+    keywords.iter().any(|k| {
+        let KeywordData { arg, .. } = &k.node;
+        arg.is_none()
+    })
+}
+
+fn has_star_args(args: &[Expr]) -> bool {
+    args.iter()
+        .any(|arg| matches!(&arg.node, ExprKind::Starred { .. }))
+}
+
+/// F502
+pub(crate) fn percent_format_expected_mapping(
+    checker: &mut Checker,
+    summary: &CFormatSummary,
+    right: &Expr,
+    location: Range,
+) {
+    if !summary.keywords.is_empty() {
+        // Tuple, List, Set (+comprehensions)
+        match right.node {
+            ExprKind::List { .. }
+            | ExprKind::Tuple { .. }
+            | ExprKind::Set { .. }
+            | ExprKind::ListComp { .. }
+            | ExprKind::SetComp { .. }
+            | ExprKind::GeneratorExp { .. } => checker.add_check(Check::new(
+                CheckKind::PercentFormatExpectedMapping,
+                location,
+            )),
+            _ => {}
+        }
+    }
+}
+
+/// F503
+pub(crate) fn percent_format_expected_sequence(
+    checker: &mut Checker,
+    summary: &CFormatSummary,
+    right: &Expr,
+    location: Range,
+) {
+    if summary.num_positional > 1
+        && matches!(
+            right.node,
+            ExprKind::Dict { .. } | ExprKind::DictComp { .. }
+        )
+    {
+        checker.add_check(Check::new(
+            CheckKind::PercentFormatExpectedSequence,
+            location,
+        ));
+    }
+}
+
+/// F504
+pub(crate) fn percent_format_extra_named_arguments(
+    checker: &mut Checker,
+    summary: &CFormatSummary,
+    right: &Expr,
+    location: Range,
+) {
+    if summary.num_positional > 0 {
+        return;
+    }
+    let ExprKind::Dict { keys, values } = &right.node else {
+        return;
+    };
+    if values.len() > keys.len() {
+        return; // contains **x splat
+    }
+
+    let missing: Vec<&str> = keys
+        .iter()
+        .filter_map(|k| match &k.node {
+            // We can only check that string literals exist
+            ExprKind::Constant {
+                value: Constant::Str(value),
+                ..
+            } => {
+                if summary.keywords.contains(value) {
+                    None
+                } else {
+                    Some(value.as_str())
+                }
+            }
+            _ => None,
+        })
+        .collect();
+
+    if missing.is_empty() {
+        return;
+    }
+
+    let mut check = Check::new(
+        CheckKind::PercentFormatExtraNamedArguments(
+            missing.iter().map(|&arg| arg.to_string()).collect(),
+        ),
+        location,
+    );
+    if checker.patch(check.kind.code()) {
+        if let Ok(fix) = remove_unused_format_arguments_from_dict(checker.locator, &missing, right)
+        {
+            check.amend(fix);
+        }
+    }
+    checker.add_check(check);
+}
+
+/// F505
+pub(crate) fn percent_format_missing_arguments(
+    checker: &mut Checker,
+    summary: &CFormatSummary,
+    right: &Expr,
+    location: Range,
+) {
+    if summary.num_positional > 0 {
+        return;
+    }
+
+    if let ExprKind::Dict { keys, values } = &right.node {
+        if values.len() > keys.len() {
+            return; // contains **x splat
+        }
+
+        let mut keywords = FxHashSet::default();
+        for key in keys {
+            match &key.node {
+                ExprKind::Constant {
+                    value: Constant::Str(value),
+                    ..
+                } => {
+                    keywords.insert(value);
+                }
+                _ => {
+                    return; // Dynamic keys present
+                }
+            }
+        }
+
+        let missing: Vec<&String> = summary
+            .keywords
+            .iter()
+            .filter(|k| !keywords.contains(k))
+            .collect();
+
+        if !missing.is_empty() {
+            checker.add_check(Check::new(
+                CheckKind::PercentFormatMissingArgument(
+                    missing.iter().map(|&s| s.clone()).collect(),
+                ),
+                location,
+            ));
+        }
+    }
+}
+
+/// F506
+pub(crate) fn percent_format_mixed_positional_and_named(
+    checker: &mut Checker,
+    summary: &CFormatSummary,
+    location: Range,
+) {
+    if !(summary.num_positional == 0 || summary.keywords.is_empty()) {
+        checker.add_check(Check::new(
+            CheckKind::PercentFormatMixedPositionalAndNamed,
+            location,
+        ));
+    }
+}
+
+/// F507
+pub(crate) fn percent_format_positional_count_mismatch(
+    checker: &mut Checker,
+    summary: &CFormatSummary,
+    right: &Expr,
+    location: Range,
+) {
+    if !summary.keywords.is_empty() {
+        return;
+    }
+
+    match &right.node {
+        ExprKind::List { elts, .. } | ExprKind::Tuple { elts, .. } | ExprKind::Set { elts, .. } => {
+            let mut found = 0;
+            for elt in elts {
+                if let ExprKind::Starred { .. } = &elt.node {
+                    return;
+                }
+                found += 1;
+            }
+
+            if found != summary.num_positional {
+                checker.add_check(Check::new(
+                    CheckKind::PercentFormatPositionalCountMismatch(summary.num_positional, found),
+                    location,
+                ));
+            }
+        }
+        _ => {}
+    }
+}
+
+/// F508
+pub(crate) fn percent_format_star_requires_sequence(
+    checker: &mut Checker,
+    summary: &CFormatSummary,
+    right: &Expr,
+    location: Range,
+) {
+    if summary.starred {
+        match &right.node {
+            ExprKind::Dict { .. } | ExprKind::DictComp { .. } => checker.add_check(Check::new(
+                CheckKind::PercentFormatStarRequiresSequence,
+                location,
+            )),
+            _ => {}
+        }
+    }
+}
+
+/// F522
+pub(crate) fn string_dot_format_extra_named_arguments(
+    checker: &mut Checker,
+    summary: &FormatSummary,
+    keywords: &[Keyword],
+    location: Range,
+) {
+    if has_star_star_kwargs(keywords) {
+        return;
+    }
+
+    let keywords = keywords.iter().filter_map(|k| {
+        let KeywordData { arg, .. } = &k.node;
+        arg.as_ref()
+    });
+
+    let missing: Vec<&str> = keywords
+        .filter_map(|arg| {
+            if summary.keywords.contains(arg) {
+                None
+            } else {
+                Some(arg.as_str())
+            }
+        })
+        .collect();
+
+    if missing.is_empty() {
+        return;
+    }
+
+    let mut check = Check::new(
+        CheckKind::StringDotFormatExtraNamedArguments(
+            missing.iter().map(|&arg| arg.to_string()).collect(),
+        ),
+        location,
+    );
+    if checker.patch(check.kind.code()) {
+        if let Ok(fix) =
+            remove_unused_keyword_arguments_from_format_call(checker.locator, &missing, location)
+        {
+            check.amend(fix);
+        }
+    }
+    checker.add_check(check);
+}
+
+/// F523
+pub(crate) fn string_dot_format_extra_positional_arguments(
+    checker: &mut Checker,
+    summary: &FormatSummary,
+    args: &[Expr],
+    location: Range,
+) {
+    if has_star_args(args) {
+        return;
+    }
+
+    let missing: Vec<usize> = (0..args.len())
+        .filter(|i| !(summary.autos.contains(i) || summary.indexes.contains(i)))
+        .collect();
+
+    if missing.is_empty() {
+        return;
+    }
+
+    checker.add_check(Check::new(
+        CheckKind::StringDotFormatExtraPositionalArguments(
+            missing
+                .iter()
+                .map(std::string::ToString::to_string)
+                .collect::<Vec<String>>(),
+        ),
+        location,
+    ));
+}
+
+/// F524
+pub(crate) fn string_dot_format_missing_argument(
+    checker: &mut Checker,
+    summary: &FormatSummary,
+    args: &[Expr],
+    keywords: &[Keyword],
+    location: Range,
+) {
+    if has_star_args(args) || has_star_star_kwargs(keywords) {
+        return;
+    }
+
+    let keywords: FxHashSet<_> = keywords
+        .iter()
+        .filter_map(|k| {
+            let KeywordData { arg, .. } = &k.node;
+            arg.as_ref()
+        })
+        .collect();
+
+    let missing: Vec<String> = summary
+        .autos
+        .iter()
+        .chain(summary.indexes.iter())
+        .filter(|&&i| i >= args.len())
+        .map(ToString::to_string)
+        .chain(
+            summary
+                .keywords
+                .iter()
+                .filter(|k| !keywords.contains(k))
+                .cloned(),
+        )
+        .collect();
+
+    if !missing.is_empty() {
+        checker.add_check(Check::new(
+            CheckKind::StringDotFormatMissingArguments(missing),
+            location,
+        ));
+    }
+}
+
+/// F525
+pub(crate) fn string_dot_format_mixing_automatic(
+    checker: &mut Checker,
+    summary: &FormatSummary,
+    location: Range,
+) {
+    if !(summary.autos.is_empty() || summary.indexes.is_empty()) {
+        checker.add_check(Check::new(
+            CheckKind::StringDotFormatMixingAutomatic,
+            location,
+        ));
+    }
+}
--- a/src/pyflakes/snapshots/ruffpyflakestests__F504_F504.py.snap
+++ b/src/pyflakes/snapshots/ruffpyflakestests__F504_F504.py.snap
@@ -11,5 +11,46 @@ expression: checks
  end_location:
    row: 3
    column: 34
-  fix: ~
+  fix:
+    content: "{a: \"?\", }"
+    location:
+      row: 3
+      column: 16
+    end_location:
+      row: 3
+      column: 34
+- kind:
+    PercentFormatExtraNamedArguments:
+      - b
+  location:
+    row: 8
+    column: 8
+  end_location:
+    row: 8
+    column: 29
+  fix:
+    content: "{\"a\": 1, }"
+    location:
+      row: 8
+      column: 10
+    end_location:
+      row: 8
+      column: 29
+- kind:
+    PercentFormatExtraNamedArguments:
+      - b
+  location:
+    row: 9
+    column: 8
+  end_location:
+    row: 9
+    column: 29
+  fix:
+    content: "{'a': 1, }"
+    location:
+      row: 9
+      column: 10
+    end_location:
+      row: 9
+      column: 29

--- a/src/pyflakes/snapshots/ruffpyflakestests__F504_F50x.py.snap
+++ b/src/pyflakes/snapshots/ruffpyflakestests__F504_F50x.py.snap
@@ -11,5 +11,12 @@ expression: checks
  end_location:
    row: 8
    column: 32
-  fix: ~
+  fix:
+    content: "{'bar': 1, }"
+    location:
+      row: 8
+      column: 12
+    end_location:
+      row: 8
+      column: 32

--- a/src/pyflakes/snapshots/ruffpyflakestests__F522_F522.py.snap
+++ b/src/pyflakes/snapshots/ruffpyflakestests__F522_F522.py.snap
@@ -11,7 +11,14 @@ expression: checks
  end_location:
    row: 1
    column: 21
-  fix: ~
+  fix:
+    content: "\"{}\".format(1, )"
+    location:
+      row: 1
+      column: 0
+    end_location:
+      row: 1
+      column: 21
 - kind:
    StringDotFormatExtraNamedArguments:
      - spam
@@ -21,7 +28,14 @@ expression: checks
  end_location:
    row: 2
    column: 34
-  fix: ~
+  fix:
+    content: "\"{bar}{}\".format(1, bar=2, )"
+    location:
+      row: 2
+      column: 0
+    end_location:
+      row: 2
+      column: 34
 - kind:
    StringDotFormatExtraNamedArguments:
      - eggs
@@ -32,5 +46,12 @@ expression: checks
  end_location:
    row: 4
    column: 51
-  fix: ~
+  fix:
+    content: "\"{bar:{spam}}\".format(bar=2, spam=3, )"
+    location:
+      row: 4
+      column: 0
+    end_location:
+      row: 4
+      column: 51

--- a/src/pyflakes/snapshots/ruffpyflakestests__F541_F541.py.snap
+++ b/src/pyflakes/snapshots/ruffpyflakestests__F541_F541.py.snap
@@ -26,4 +26,12 @@ expression: checks
    row: 7
    column: 10
  fix: ~
+- kind: FStringMissingPlaceholders
+  location:
+    row: 12
+    column: 4
+  end_location:
+    row: 12
+    column: 16
+  fix: ~

--- a/src/pyflakes/snapshots/ruffpyflakestests__F821_F821_0.py.snap
+++ b/src/pyflakes/snapshots/ruffpyflakestests__F821_F821_0.py.snap
@@ -71,8 +71,8 @@ expression: checks
    row: 89
    column: 4
  end_location:
-    row: 89
-    column: 8
+    row: 90
+    column: 10
  fix: ~
 - kind:
    UndefinedName: PEP593Test123
--- a/src/pyflakes/snapshots/ruffpyflakestests__F821_F821_6.py.snap
+++ b/src/pyflakes/snapshots/ruffpyflakestests__F821_F821_6.py.snap
@@ -0,0 +1,6 @@
+---
+source: src/pyflakes/mod.rs
+expression: checks
+---
+[]
+
--- a/src/pylint/mod.rs
+++ b/src/pylint/mod.rs
@@ -14,6 +14,8 @@ mod tests {
    #[test_case(CheckCode::PLC0414, Path::new("import_aliasing.py"); "PLC0414")]
    #[test_case(CheckCode::PLC2201, Path::new("misplaced_comparison_constant.py"); "PLC2201")]
    #[test_case(CheckCode::PLC3002, Path::new("unnecessary_direct_lambda_call.py"); "PLC3002")]
+    #[test_case(CheckCode::PLE0117, Path::new("nonlocal_without_binding.py"); "PLE0117")]
+    #[test_case(CheckCode::PLE0118, Path::new("used_prior_global_declaration.py"); "PLE0118")]
    #[test_case(CheckCode::PLE1142, Path::new("await_outside_async.py"); "PLE1142")]
    #[test_case(CheckCode::PLR0206, Path::new("property_with_parameters.py"); "PLR0206")]
    #[test_case(CheckCode::PLR0402, Path::new("import_aliasing.py"); "PLR0402")]
@@ -26,6 +28,7 @@ mod tests {
    #[test_case(CheckCode::PLR1722, Path::new("consider_using_sys_exit_5.py"); "PLR1722_5")]
    #[test_case(CheckCode::PLR1722, Path::new("consider_using_sys_exit_6.py"); "PLR1722_6")]
    #[test_case(CheckCode::PLW0120, Path::new("useless_else_on_loop.py"); "PLW0120")]
+    #[test_case(CheckCode::PLW0602, Path::new("global_variable_not_assigned.py"); "PLW0602")]
    fn checks(check_code: CheckCode, path: &Path) -> Result<()> {
        let snapshot = format!("{}_{}", check_code.as_ref(), path.to_string_lossy());
        let mut checks = test_path(
--- a/src/pylint/plugins/mod.rs
+++ b/src/pylint/plugins/mod.rs
@@ -5,6 +5,7 @@ pub use property_with_parameters::property_with_parameters;
 pub use unnecessary_direct_lambda_call::unnecessary_direct_lambda_call;
 pub use use_from_import::use_from_import;
 pub use use_sys_exit::use_sys_exit;
+pub use used_prior_global_declaration::used_prior_global_declaration;
 pub use useless_else_on_loop::useless_else_on_loop;
 pub use useless_import_alias::useless_import_alias;

@@ -15,5 +16,6 @@ mod property_with_parameters;
 mod unnecessary_direct_lambda_call;
 mod use_from_import;
 mod use_sys_exit;
+mod used_prior_global_declaration;
 mod useless_else_on_loop;
 mod useless_import_alias;
--- a/src/pylint/plugins/used_prior_global_declaration.rs
+++ b/src/pylint/plugins/used_prior_global_declaration.rs
@@ -0,0 +1,23 @@
+use rustpython_ast::Expr;
+
+use crate::ast::types::{Range, ScopeKind};
+use crate::check_ast::Checker;
+use crate::checks::CheckKind;
+use crate::Check;
+
+/// PLE0118
+pub fn used_prior_global_declaration(checker: &mut Checker, name: &str, expr: &Expr) {
+    let globals = match &checker.current_scope().kind {
+        ScopeKind::Class(class_def) => &class_def.globals,
+        ScopeKind::Function(function_def) => &function_def.globals,
+        _ => return,
+    };
+    if let Some(stmt) = globals.get(name) {
+        if expr.location < stmt.location {
+            checker.add_check(Check::new(
+                CheckKind::UsedPriorGlobalDeclaration(name.to_string(), stmt.location.row()),
+                Range::from_located(expr),
+            ));
+        }
+    }
+}
--- a/src/pylint/snapshots/ruffpylinttests__PLE0117_nonlocal_without_binding.py.snap
+++ b/src/pylint/snapshots/ruffpylinttests__PLE0117_nonlocal_without_binding.py.snap
@@ -0,0 +1,32 @@
+---
+source: src/pylint/mod.rs
+expression: checks
+---
+- kind:
+    NonlocalWithoutBinding: x
+  location:
+    row: 5
+    column: 4
+  end_location:
+    row: 5
+    column: 14
+  fix: ~
+- kind:
+    NonlocalWithoutBinding: y
+  location:
+    row: 9
+    column: 4
+  end_location:
+    row: 9
+    column: 14
+  fix: ~
+- kind:
+    NonlocalWithoutBinding: y
+  location:
+    row: 19
+    column: 8
+  end_location:
+    row: 19
+    column: 18
+  fix: ~
+
--- a/src/pylint/snapshots/ruffpylinttests__PLE0118_used_prior_global_declaration.py.snap
+++ b/src/pylint/snapshots/ruffpylinttests__PLE0118_used_prior_global_declaration.py.snap
@@ -0,0 +1,137 @@
+---
+source: src/pylint/mod.rs
+expression: checks
+---
+- kind:
+    UsedPriorGlobalDeclaration:
+      - x
+      - 7
+  location:
+    row: 5
+    column: 10
+  end_location:
+    row: 5
+    column: 11
+  fix: ~
+- kind:
+    UsedPriorGlobalDeclaration:
+      - x
+      - 17
+  location:
+    row: 15
+    column: 10
+  end_location:
+    row: 15
+    column: 11
+  fix: ~
+- kind:
+    UsedPriorGlobalDeclaration:
+      - x
+      - 25
+  location:
+    row: 23
+    column: 10
+  end_location:
+    row: 23
+    column: 11
+  fix: ~
+- kind:
+    UsedPriorGlobalDeclaration:
+      - x
+      - 35
+  location:
+    row: 33
+    column: 10
+  end_location:
+    row: 33
+    column: 11
+  fix: ~
+- kind:
+    UsedPriorGlobalDeclaration:
+      - x
+      - 43
+  location:
+    row: 41
+    column: 4
+  end_location:
+    row: 41
+    column: 5
+  fix: ~
+- kind:
+    UsedPriorGlobalDeclaration:
+      - x
+      - 53
+  location:
+    row: 51
+    column: 4
+  end_location:
+    row: 51
+    column: 5
+  fix: ~
+- kind:
+    UsedPriorGlobalDeclaration:
+      - x
+      - 61
+  location:
+    row: 59
+    column: 8
+  end_location:
+    row: 59
+    column: 9
+  fix: ~
+- kind:
+    UsedPriorGlobalDeclaration:
+      - x
+      - 71
+  location:
+    row: 69
+    column: 8
+  end_location:
+    row: 69
+    column: 9
+  fix: ~
+- kind:
+    UsedPriorGlobalDeclaration:
+      - x
+      - 79
+  location:
+    row: 77
+    column: 8
+  end_location:
+    row: 77
+    column: 9
+  fix: ~
+- kind:
+    UsedPriorGlobalDeclaration:
+      - x
+      - 89
+  location:
+    row: 87
+    column: 8
+  end_location:
+    row: 87
+    column: 9
+  fix: ~
+- kind:
+    UsedPriorGlobalDeclaration:
+      - x
+      - 97
+  location:
+    row: 95
+    column: 8
+  end_location:
+    row: 95
+    column: 9
+  fix: ~
+- kind:
+    UsedPriorGlobalDeclaration:
+      - x
+      - 107
+  location:
+    row: 105
+    column: 8
+  end_location:
+    row: 105
+    column: 9
+  fix: ~
+
--- a/src/pylint/snapshots/ruffpylinttests__PLW0602_global_variable_not_assigned.py.snap
+++ b/src/pylint/snapshots/ruffpylinttests__PLW0602_global_variable_not_assigned.py.snap
@@ -0,0 +1,23 @@
+---
+source: src/pylint/mod.rs
+expression: checks
+---
+- kind:
+    GlobalVariableNotAssigned: x
+  location:
+    row: 5
+    column: 4
+  end_location:
+    row: 5
+    column: 12
+  fix: ~
+- kind:
+    GlobalVariableNotAssigned: x
+  location:
+    row: 9
+    column: 4
+  end_location:
+    row: 9
+    column: 12
+  fix: ~
+
--- a/src/python/string.rs
+++ b/src/python/string.rs
@@ -1,3 +1,9 @@
+use once_cell::sync::Lazy;
+use regex::Regex;
+
+pub static STRING_QUOTE_PREFIX_REGEX: Lazy<Regex> =
+    Lazy::new(|| Regex::new(r#"^(?i)[urb]*['"](?P<raw>.*)['"]$"#).unwrap());
+
 pub fn is_lower(s: &str) -> bool {
    let mut cased = false;
    for c in s.chars() {
@@ -22,9 +28,22 @@ pub fn is_upper(s: &str) -> bool {
    cased
 }

+/// Remove prefixes (u, r, b) and quotes around a string. This expects the given
+/// string to be a valid Python string representation, it doesn't do any
+/// validation.
+pub fn strip_quotes_and_prefixes(s: &str) -> &str {
+    match STRING_QUOTE_PREFIX_REGEX.captures(s) {
+        Some(caps) => match caps.name("raw") {
+            Some(m) => m.as_str(),
+            None => s,
+        },
+        None => s,
+    }
+}
+
 #[cfg(test)]
 mod tests {
-    use crate::python::string::{is_lower, is_upper};
+    use crate::python::string::{is_lower, is_upper, strip_quotes_and_prefixes};

    #[test]
    fn test_is_lower() {
@@ -47,4 +66,12 @@ mod tests {
        assert!(!is_upper(""));
        assert!(!is_upper("_"));
    }
+
+    #[test]
+    fn test_strip_quotes_and_prefixes() {
+        assert_eq!(strip_quotes_and_prefixes(r#"'a'"#), "a");
+        assert_eq!(strip_quotes_and_prefixes(r#"bur'a'"#), "a");
+        assert_eq!(strip_quotes_and_prefixes(r#"UrB'a'"#), "a");
+        assert_eq!(strip_quotes_and_prefixes(r#""a""#), "a");
+    }
 }
--- a/src/settings/configuration.rs
+++ b/src/settings/configuration.rs
@@ -11,6 +11,7 @@ use regex::Regex;
 use rustc_hash::FxHashSet;

 use crate::checks_gen::{CheckCodePrefix, CATEGORIES};
+use crate::cli::{collect_per_file_ignores, Overrides};
 use crate::settings::pyproject::load_options;
 use crate::settings::types::{FilePattern, PerFileIgnore, PythonVersion, SerializationFormat};
 use crate::{
@@ -185,4 +186,55 @@ impl Configuration {
                .unwrap_or_default(),
        })
    }
+
+    pub fn merge(&mut self, overrides: Overrides) {
+        if let Some(dummy_variable_rgx) = overrides.dummy_variable_rgx {
+            self.dummy_variable_rgx = dummy_variable_rgx;
+        }
+        if let Some(exclude) = overrides.exclude {
+            self.exclude = exclude;
+        }
+        if let Some(extend_exclude) = overrides.extend_exclude {
+            self.extend_exclude = extend_exclude;
+        }
+        if let Some(extend_ignore) = overrides.extend_ignore {
+            self.extend_ignore = extend_ignore;
+        }
+        if let Some(extend_select) = overrides.extend_select {
+            self.extend_select = extend_select;
+        }
+        if let Some(fix) = overrides.fix {
+            self.fix = fix;
+        }
+        if let Some(fixable) = overrides.fixable {
+            self.fixable = fixable;
+        }
+        if let Some(format) = overrides.format {
+            self.format = format;
+        }
+        if let Some(ignore) = overrides.ignore {
+            self.ignore = ignore;
+        }
+        if let Some(line_length) = overrides.line_length {
+            self.line_length = line_length;
+        }
+        if let Some(max_complexity) = overrides.max_complexity {
+            self.mccabe.max_complexity = max_complexity;
+        }
+        if let Some(per_file_ignores) = overrides.per_file_ignores {
+            self.per_file_ignores = collect_per_file_ignores(per_file_ignores);
+        }
+        if let Some(select) = overrides.select {
+            self.select = select;
+        }
+        if let Some(show_source) = overrides.show_source {
+            self.show_source = show_source;
+        }
+        if let Some(target_version) = overrides.target_version {
+            self.target_version = target_version;
+        }
+        if let Some(unfixable) = overrides.unfixable {
+            self.unfixable = unfixable;
+        }
+    }
 }
--- a/src/settings/mod.rs
+++ b/src/settings/mod.rs
@@ -15,7 +15,7 @@ use rustc_hash::FxHashSet;
 use crate::checks::CheckCode;
 use crate::checks_gen::{CheckCodePrefix, SuffixLength};
 use crate::settings::configuration::Configuration;
-use crate::settings::types::{FilePattern, PerFileIgnore, PythonVersion, SerializationFormat};
+use crate::settings::types::{FilePattern, PerFileIgnore, PythonVersion};
 use crate::{
    flake8_annotations, flake8_bugbear, flake8_import_conventions, flake8_quotes,
    flake8_tidy_imports, fs, isort, mccabe, pep8_naming, pyupgrade,
@@ -36,7 +36,6 @@ pub struct Settings {
    pub extend_exclude: GlobSet,
    pub external: FxHashSet<String>,
    pub fixable: FxHashSet<CheckCode>,
-    pub format: SerializationFormat,
    pub ignore_init_module_imports: bool,
    pub line_length: usize,
    pub per_file_ignores: Vec<(GlobMatcher, GlobMatcher, FxHashSet<CheckCode>)>,
@@ -79,7 +78,6 @@ impl Settings {
            extend_exclude: resolve_globset(config.extend_exclude, project_root)?,
            external: FxHashSet::from_iter(config.external),
            fixable: resolve_codes(&config.fixable, &config.unfixable),
-            format: config.format,
            flake8_annotations: config.flake8_annotations,
            flake8_bugbear: config.flake8_bugbear,
            flake8_import_conventions: config.flake8_import_conventions,
@@ -107,7 +105,6 @@ impl Settings {
            extend_exclude: GlobSet::empty(),
            external: FxHashSet::default(),
            fixable: FxHashSet::from_iter([check_code]),
-            format: SerializationFormat::Text,
            ignore_init_module_imports: false,
            line_length: 88,
            per_file_ignores: vec![],
@@ -135,7 +132,6 @@ impl Settings {
            extend_exclude: GlobSet::empty(),
            external: FxHashSet::default(),
            fixable: FxHashSet::from_iter(check_codes),
-            format: SerializationFormat::Text,
            ignore_init_module_imports: false,
            line_length: 88,
            per_file_ignores: vec![],
--- a/src/settings/options.rs
+++ b/src/settings/options.rs
@@ -20,7 +20,7 @@ pub struct Options {
            `RUF002`, and `RUF003`.
        "#,
        default = r#"[]"#,
-        value_type = "Vec<char>",
+        value_type = "Vec<a test>",
        example = r#"
            # Allow minus-sign (U+2212), greek-small-letter-rho (U+03C1), and the asterisk-operator (U+2217),
            # which could be confused for "-", "p", and "*", respectively.
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