Bump version to 0.0.175

.github/workflows/ruff.yaml

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

.pre-commit-config.yaml

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

Cargo.lock

@@ -724,7 +724,7 @@ checksum = "0ce7134b9999ecaf8bcd65542e436736ef32ddca1b3e06094cb6ec5755203b80"
 
 [[package]]
 name = "flake8-to-ruff"
-version = "0.0.170-dev.0"
+version = "0.0.175-dev.0"
 dependencies = [
  "anyhow",
  "clap 4.0.29",
@@ -1821,7 +1821,7 @@ dependencies = [
 
 [[package]]
 name = "ruff"
-version = "0.0.170"
+version = "0.0.175"
 dependencies = [
  "annotate-snippets 0.9.1",
  "anyhow",
@@ -1874,7 +1874,7 @@ dependencies = [
 
 [[package]]
 name = "ruff_dev"
-version = "0.0.170"
+version = "0.0.175"
 dependencies = [
  "anyhow",
  "clap 4.0.29",
@@ -1892,7 +1892,7 @@ dependencies = [
 
 [[package]]
 name = "ruff_macros"
-version = "0.0.170"
+version = "0.0.175"
 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",

Cargo.toml

@@ -6,7 +6,7 @@ members = [
 
 [package]
 name = "ruff"
-version = "0.0.170"
+version = "0.0.175"
 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.170", path = "ruff_macros" }
+ruff_macros = { version = "0.0.175", 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"] }

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).
 
@@ -120,12 +121,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 +154,7 @@ Ruff also works with [pre-commit](https://pre-commit.com):
 ```yaml
 repos:
   - repo: https://github.com/charliermarsh/ruff-pre-commit
-    rev: v0.0.170
+    rev: v0.0.175
     hooks:
       - id: ruff
 ```
@@ -412,14 +419,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 |  |
@@ -438,11 +445,13 @@ For more, see [Pyflakes](https://pypi.org/project/pyflakes/2.5.0/) on PyPI.
 | F706 | ReturnOutsideFunction | `return` statement outside of a function/method |  |
 | F707 | DefaultExceptNotLast | An `except` block as not the last exception handler |  |
 | F722 | ForwardAnnotationSyntaxError | Syntax error in forward annotation: `...` |  |
+| F811 | RedefinedWhileUnused | Redefinition of unused `...` from line 1 |  |
 | F821 | UndefinedName | Undefined name `...` |  |
 | F822 | UndefinedExport | Undefined name `...` in `__all__` |  |
 | F823 | UndefinedLocal | Local variable `...` referenced before assignment |  |
 | F831 | DuplicateArgumentName | Duplicate argument name in function definition |  |
 | F841 | UnusedVariable | Local variable `...` is assigned to but never used |  |
+| F842 | UnusedAnnotation | Local variable `...` is annotated but never used |  |
 | F901 | RaiseNotImplemented | `raise NotImplemented` should be `raise NotImplementedError` | 🛠 |
 
 ### pycodestyle (E, W)
@@ -515,6 +524,7 @@ For more, see [pydocstyle](https://pypi.org/project/pydocstyle/6.1.1/) on PyPI.
 | D214 | SectionNotOverIndented | Section is over-indented ("Returns") | 🛠 |
 | D215 | SectionUnderlineNotOverIndented | Section underline is over-indented ("Returns") | 🛠 |
 | D300 | UsesTripleQuotes | Use """triple double quotes""" |  |
+| D301 | UsesRPrefixForBackslashedContent | Use r""" if any backslashes in a docstring |  |
 | D400 | EndsInPeriod | First line should end with a period | 🛠 |
 | D402 | NoSignature | First line should not be the function's signature |  |
 | D403 | FirstLineCapitalized | First word of the first line should be properly capitalized |  |
@@ -806,12 +816,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)
 
@@ -948,7 +961,7 @@ automatically convert your existing configuration.)
 Ruff can be used as a drop-in replacement for Flake8 when used (1) without or with a small number of
 plugins, (2) alongside Black, and (3) on Python 3 code.
 
-Under those conditions, Ruff implements every rule in Flake8, with the exception of `F811`.
+Under those conditions, Ruff implements every rule in Flake8.
 
 Ruff also re-implements some of the most popular Flake8 plugins and related code quality tools
 natively, including:
@@ -1980,6 +1993,10 @@ from .utils import (
 )
 ```
 
+Note that this setting is only effective when combined with `combine-as-imports = true`.
+When `combine-as-imports` isn't enabled, every aliased `import from` will be given its
+own line, in which case, wrapping is not necessary.
+
 **Default value**: `false`
 
 **Type**: `bool`
@@ -1989,6 +2006,7 @@ from .utils import (
 ```toml
 [tool.ruff.isort]
 force-wrap-aliases = true
+combine-as-imports = true
 ```
 
 ---

flake8_to_ruff/Cargo.lock

@@ -771,7 +771,7 @@ checksum = "0ce7134b9999ecaf8bcd65542e436736ef32ddca1b3e06094cb6ec5755203b80"
 
 [[package]]
 name = "flake8_to_ruff"
-version = "0.0.170"
+version = "0.0.175"
 dependencies = [
  "anyhow",
  "clap",
@@ -1975,7 +1975,7 @@ dependencies = [
 
 [[package]]
 name = "ruff"
-version = "0.0.170"
+version = "0.0.175"
 dependencies = [
  "anyhow",
  "bincode",
@@ -2028,7 +2028,7 @@ dependencies = [
 [[package]]
 name = "rustpython-ast"
 version = "0.1.0"
-source = "git+https://github.com/RustPython/RustPython.git?rev=28f9f65ccc625f00835d84bbb5fba274dce5aa89#28f9f65ccc625f00835d84bbb5fba274dce5aa89"
+source = "git+https://github.com/RustPython/RustPython.git?rev=2edd0d264c50c7807bcff03a52a6509e8b7f187f#2edd0d264c50c7807bcff03a52a6509e8b7f187f"
 dependencies = [
  "num-bigint",
  "rustpython-common",
@@ -2038,7 +2038,7 @@ dependencies = [
 [[package]]
 name = "rustpython-common"
 version = "0.0.0"
-source = "git+https://github.com/RustPython/RustPython.git?rev=28f9f65ccc625f00835d84bbb5fba274dce5aa89#28f9f65ccc625f00835d84bbb5fba274dce5aa89"
+source = "git+https://github.com/RustPython/RustPython.git?rev=2edd0d264c50c7807bcff03a52a6509e8b7f187f#2edd0d264c50c7807bcff03a52a6509e8b7f187f"
 dependencies = [
  "ascii",
  "cfg-if 1.0.0",
@@ -2061,7 +2061,7 @@ dependencies = [
 [[package]]
 name = "rustpython-compiler-core"
 version = "0.1.2"
-source = "git+https://github.com/RustPython/RustPython.git?rev=28f9f65ccc625f00835d84bbb5fba274dce5aa89#28f9f65ccc625f00835d84bbb5fba274dce5aa89"
+source = "git+https://github.com/RustPython/RustPython.git?rev=2edd0d264c50c7807bcff03a52a6509e8b7f187f#2edd0d264c50c7807bcff03a52a6509e8b7f187f"
 dependencies = [
  "bincode",
  "bitflags",
@@ -2078,7 +2078,7 @@ dependencies = [
 [[package]]
 name = "rustpython-parser"
 version = "0.1.2"
-source = "git+https://github.com/RustPython/RustPython.git?rev=28f9f65ccc625f00835d84bbb5fba274dce5aa89#28f9f65ccc625f00835d84bbb5fba274dce5aa89"
+source = "git+https://github.com/RustPython/RustPython.git?rev=2edd0d264c50c7807bcff03a52a6509e8b7f187f#2edd0d264c50c7807bcff03a52a6509e8b7f187f"
 dependencies = [
  "ahash",
  "anyhow",

flake8_to_ruff/Cargo.toml

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

flake8_to_ruff/src/converter.rs

@@ -512,6 +512,7 @@ mod tests {
                 CheckCodePrefix::D214,
                 CheckCodePrefix::D215,
                 CheckCodePrefix::D300,
+                CheckCodePrefix::D301,
                 CheckCodePrefix::D400,
                 CheckCodePrefix::D403,
                 CheckCodePrefix::D404,

flake8_to_ruff/src/parser.rs

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

flake8_to_ruff/src/plugin.rs

@@ -162,6 +162,7 @@ impl DocstringConvention {
                 // CheckCodePrefix::D214,
                 // CheckCodePrefix::D215,
                 CheckCodePrefix::D300,
+                CheckCodePrefix::D301,
                 CheckCodePrefix::D400,
                 CheckCodePrefix::D402,
                 CheckCodePrefix::D403,
@@ -209,6 +210,7 @@ impl DocstringConvention {
                 CheckCodePrefix::D214,
                 CheckCodePrefix::D215,
                 CheckCodePrefix::D300,
+                CheckCodePrefix::D301,
                 CheckCodePrefix::D400,
                 // CheckCodePrefix::D402,
                 CheckCodePrefix::D403,
@@ -257,6 +259,7 @@ impl DocstringConvention {
                 CheckCodePrefix::D214,
                 // CheckCodePrefix::D215,
                 CheckCodePrefix::D300,
+                CheckCodePrefix::D301,
                 // CheckCodePrefix::D400,
                 CheckCodePrefix::D402,
                 CheckCodePrefix::D403,

resources/test/fixtures/eradicate/ERA001.py

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

resources/test/fixtures/flake8_return/RET504.py

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

resources/test/fixtures/pyflakes/F504.py

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

resources/test/fixtures/pyflakes/F541.py

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

resources/test/fixtures/pyflakes/F811_0.py

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

resources/test/fixtures/pyflakes/F811_1.py

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

resources/test/fixtures/pyflakes/F811_10.py

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

resources/test/fixtures/pyflakes/F811_11.py

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

resources/test/fixtures/pyflakes/F811_12.py

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

resources/test/fixtures/pyflakes/F811_13.py

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

resources/test/fixtures/pyflakes/F811_14.py

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

resources/test/fixtures/pyflakes/F811_15.py

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

resources/test/fixtures/pyflakes/F811_16.py

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

resources/test/fixtures/pyflakes/F811_17.py

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

resources/test/fixtures/pyflakes/F811_18.py

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

resources/test/fixtures/pyflakes/F811_19.py

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

resources/test/fixtures/pyflakes/F811_2.py

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

resources/test/fixtures/pyflakes/F811_20.py

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

resources/test/fixtures/pyflakes/F811_3.py

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

resources/test/fixtures/pyflakes/F811_4.py

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

resources/test/fixtures/pyflakes/F811_5.py

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

resources/test/fixtures/pyflakes/F811_6.py

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

resources/test/fixtures/pyflakes/F811_7.py

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

resources/test/fixtures/pyflakes/F811_8.py

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

resources/test/fixtures/pyflakes/F811_9.py

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

resources/test/fixtures/pyflakes/F842.py

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

resources/test/fixtures/pylint/global_variable_not_assigned.py

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

resources/test/fixtures/pylint/nonlocal_without_binding.py

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

resources/test/fixtures/pylint/used_prior_global_declaration.py

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

resources/test/fixtures/pylint/useless_else_on_loop.py

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

ruff_dev/Cargo.toml

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

ruff_macros/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ruff_macros"
-version = "0.0.170"
+version = "0.0.175"
 edition = "2021"
 
 [lib]

src/ast/branch_detection.rs

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

src/ast/mod.rs

@@ -1,3 +1,4 @@
+pub mod branch_detection;
 pub mod cast;
 pub mod function_type;
 pub mod helpers;

src/ast/operations.rs

@@ -1,12 +1,15 @@
+use rustc_hash::FxHashMap;
 use rustpython_ast::{Cmpop, Located};
 use rustpython_parser::ast::{Constant, Expr, ExprKind, Stmt, StmtKind};
 use rustpython_parser::lexer;
 use rustpython_parser::lexer::Tok;
 
-use crate::ast::types::{BindingKind, Scope};
+use crate::ast::types::{Binding, BindingKind, Scope};
+use crate::ast::visitor;
+use crate::ast::visitor::Visitor;
 
 /// Extract the names bound to a given __all__ assignment.
-pub fn extract_all_names(stmt: &Stmt, scope: &Scope) -> Vec<String> {
+pub fn extract_all_names(stmt: &Stmt, scope: &Scope, bindings: &[Binding]) -> Vec<String> {
     fn add_to_names(names: &mut Vec<String>, elts: &[Expr]) {
         for elt in elts {
             if let ExprKind::Constant {
@@ -23,8 +26,8 @@ pub fn extract_all_names(stmt: &Stmt, scope: &Scope) -> Vec<String> {
 
     // Grab the existing bound __all__ values.
     if let StmtKind::AugAssign { .. } = &stmt.node {
-        if let Some(binding) = scope.values.get("__all__") {
-            if let BindingKind::Export(existing) = &binding.kind {
+        if let Some(index) = scope.values.get("__all__") {
+            if let BindingKind::Export(existing) = &bindings[*index].kind {
                 names.extend_from_slice(existing);
             }
         }
@@ -69,6 +72,38 @@ pub fn extract_all_names(stmt: &Stmt, scope: &Scope) -> Vec<String> {
     names
 }
 
+#[derive(Default)]
+struct GlobalVisitor<'a> {
+    globals: FxHashMap<&'a str, &'a Stmt>,
+}
+
+impl<'a> Visitor<'a> for GlobalVisitor<'a> {
+    fn visit_stmt(&mut self, stmt: &'a Stmt) {
+        match &stmt.node {
+            StmtKind::Global { names } => {
+                for name in names {
+                    self.globals.insert(name, stmt);
+                }
+            }
+            StmtKind::FunctionDef { .. }
+            | StmtKind::AsyncFunctionDef { .. }
+            | StmtKind::ClassDef { .. } => {
+                // Don't recurse.
+            }
+            _ => visitor::walk_stmt(self, stmt),
+        }
+    }
+}
+
+/// Extract a map from global name to its last-defining `Stmt`.
+pub fn extract_globals(body: &[Stmt]) -> FxHashMap<&str, &Stmt> {
+    let mut visitor = GlobalVisitor::default();
+    for stmt in body {
+        visitor.visit_stmt(stmt);
+    }
+    visitor.globals
+}
+
 /// Check if a node is parent of a conditional branch.
 pub fn on_conditional_branch<'a>(parents: &mut impl Iterator<Item = &'a Stmt>) -> bool {
     parents.any(|parent| {

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,
-    pub values: FxHashMap<&'a str, Binding>,
+    /// 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,42 +94,120 @@ impl<'a> Scope<'a> {
             import_starred: false,
             uses_locals: false,
             values: FxHashMap::default(),
+            overridden: Vec::new(),
         }
     }
 }
 
-#[derive(Clone, Debug)]
-pub struct BindingContext {
-    pub defined_by: usize,
-    pub defined_in: Option<usize>,
-}
-
 #[derive(Clone, Debug)]
 pub enum BindingKind {
     Annotation,
     Argument,
     Assignment,
-    // TODO(charlie): This seems to be a catch-all.
     Binding,
     LoopVar,
     Global,
     Nonlocal,
     Builtin,
     ClassDefinition,
-    Definition,
+    FunctionDefinition,
     Export(Vec<String>),
     FutureImportation,
     StarImportation(Option<usize>, Option<String>),
-    Importation(String, String, BindingContext),
-    FromImportation(String, String, BindingContext),
-    SubmoduleImportation(String, String, BindingContext),
+    Importation(String, String),
+    FromImportation(String, String),
+    SubmoduleImportation(String, String),
 }
 
 #[derive(Clone, Debug)]
-pub struct Binding {
+pub struct Binding<'a> {
     pub kind: BindingKind,
     pub range: Range,
+    /// The statement in which the `Binding` was defined.
+    pub source: Option<RefEquality<'a, Stmt>>,
     /// Tuple of (scope index, range) indicating the scope and range at which
     /// the binding was last used.
     pub used: Option<(usize, Range)>,
 }
+
+// Pyflakes defines the following binding hierarchy (via inheritance):
+//   Binding
+//    ExportBinding
+//    Annotation
+//    Argument
+//    Assignment
+//      NamedExprAssignment
+//    Definition
+//      FunctionDefinition
+//      ClassDefinition
+//      Builtin
+//      Importation
+//        SubmoduleImportation
+//        ImportationFrom
+//        StarImportation
+//        FutureImportation
+
+impl<'a> Binding<'a> {
+    pub fn is_definition(&self) -> bool {
+        matches!(
+            self.kind,
+            BindingKind::ClassDefinition
+                | BindingKind::FunctionDefinition
+                | BindingKind::Builtin
+                | BindingKind::FutureImportation
+                | BindingKind::StarImportation(..)
+                | BindingKind::Importation(..)
+                | BindingKind::FromImportation(..)
+                | BindingKind::SubmoduleImportation(..)
+        )
+    }
+
+    pub fn redefines(&self, existing: &'a Binding) -> bool {
+        match &self.kind {
+            BindingKind::Importation(_, full_name) | BindingKind::FromImportation(_, full_name) => {
+                if let BindingKind::SubmoduleImportation(_, existing_full_name) = &existing.kind {
+                    return full_name == existing_full_name;
+                }
+            }
+            BindingKind::SubmoduleImportation(_, full_name) => {
+                if let BindingKind::Importation(_, existing_full_name)
+                | BindingKind::FromImportation(_, existing_full_name)
+                | BindingKind::SubmoduleImportation(_, existing_full_name) = &existing.kind
+                {
+                    return full_name == existing_full_name;
+                }
+            }
+            BindingKind::Annotation => {
+                return false;
+            }
+            BindingKind::FutureImportation => {
+                return false;
+            }
+            BindingKind::StarImportation(..) => {
+                return false;
+            }
+            _ => {}
+        }
+        existing.is_definition()
+    }
+}
+
+#[derive(Debug, Copy, Clone)]
+pub struct RefEquality<'a, T>(pub &'a T);
+
+impl<'a, T> std::hash::Hash for RefEquality<'a, T> {
+    fn hash<H>(&self, state: &mut H)
+    where
+        H: std::hash::Hasher,
+    {
+        (self.0 as *const T).hash(state);
+    }
+}
+
+impl<'a, 'b, T> PartialEq<RefEquality<'b, T>> for RefEquality<'a, T> {
+    fn eq(&self, other: &RefEquality<'b, T>) -> bool {
+        std::ptr::eq(self.0, other.0)
+    }
+}
+
+impl<'a, T> Eq for RefEquality<'a, T> {}

src/ast/visitor.rs

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

src/ast/whitespace.rs

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

src/checks.rs

@@ -87,22 +87,27 @@ pub enum CheckCode {
     F706,
     F707,
     F722,
+    F811,
     F821,
     F822,
     F823,
     F831,
     F841,
+    F842,
     F901,
     // pylint
     PLC0414,
     PLC2201,
     PLC3002,
+    PLE0117,
+    PLE0118,
     PLE1142,
     PLR0206,
     PLR0402,
     PLR1701,
     PLR1722,
     PLW0120,
+    PLW0602,
     // flake8-builtins
     A001,
     A002,
@@ -242,6 +247,7 @@ pub enum CheckCode {
     D214,
     D215,
     D300,
+    D301,
     D400,
     D402,
     D403,
@@ -616,6 +622,7 @@ pub enum CheckKind {
     PercentFormatStarRequiresSequence,
     PercentFormatUnsupportedFormatCharacter(char),
     RaiseNotImplemented,
+    RedefinedWhileUnused(String, usize),
     ReturnOutsideFunction,
     StringDotFormatExtraNamedArguments(Vec<String>),
     StringDotFormatExtraPositionalArguments(Vec<String>),
@@ -625,20 +632,24 @@ pub enum CheckKind {
     TwoStarredExpressions,
     UndefinedExport(String),
     UndefinedLocal(String),
+    UnusedAnnotation(String),
     UndefinedName(String),
     UnusedImport(String, bool),
     UnusedVariable(String),
     YieldOutsideFunction(DeferralKeyword),
     // pylint
-    ConsiderMergingIsinstance(String, Vec<String>),
-    UselessImportAlias,
-    MisplacedComparisonConstant(String),
-    UnnecessaryDirectLambdaCall,
-    PropertyWithParameters,
-    ConsiderUsingFromImport(String, String),
     AwaitOutsideAsync,
-    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),
@@ -794,6 +805,7 @@ pub enum CheckKind {
     SectionUnderlineMatchesSectionLength(String),
     SectionUnderlineNotOverIndented(String),
     SkipDocstring,
+    UsesRPrefixForBackslashedContent,
     UsesTripleQuotes,
     // pep8-naming
     InvalidClassName(String),
@@ -932,16 +944,20 @@ impl CheckCode {
             CheckCode::F706 => CheckKind::ReturnOutsideFunction,
             CheckCode::F707 => CheckKind::DefaultExceptNotLast,
             CheckCode::F722 => CheckKind::ForwardAnnotationSyntaxError("...".to_string()),
+            CheckCode::F811 => CheckKind::RedefinedWhileUnused("...".to_string(), 1),
             CheckCode::F821 => CheckKind::UndefinedName("...".to_string()),
             CheckCode::F822 => CheckKind::UndefinedExport("...".to_string()),
             CheckCode::F823 => CheckKind::UndefinedLocal("...".to_string()),
             CheckCode::F831 => CheckKind::DuplicateArgumentName,
             CheckCode::F841 => CheckKind::UnusedVariable("...".to_string()),
+            CheckCode::F842 => CheckKind::UnusedAnnotation("...".to_string()),
             CheckCode::F901 => CheckKind::RaiseNotImplemented,
             // pylint
             CheckCode::PLC0414 => CheckKind::UselessImportAlias,
             CheckCode::PLC2201 => CheckKind::MisplacedComparisonConstant("...".to_string()),
             CheckCode::PLC3002 => CheckKind::UnnecessaryDirectLambdaCall,
+            CheckCode::PLE0117 => CheckKind::NonlocalWithoutBinding("...".to_string()),
+            CheckCode::PLE0118 => CheckKind::UsedPriorGlobalDeclaration("...".to_string(), 1),
             CheckCode::PLE1142 => CheckKind::AwaitOutsideAsync,
             CheckCode::PLR0402 => {
                 CheckKind::ConsiderUsingFromImport("...".to_string(), "...".to_string())
@@ -952,6 +968,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()),
@@ -1109,6 +1126,7 @@ impl CheckCode {
             CheckCode::D214 => CheckKind::SectionNotOverIndented("Returns".to_string()),
             CheckCode::D215 => CheckKind::SectionUnderlineNotOverIndented("Returns".to_string()),
             CheckCode::D300 => CheckKind::UsesTripleQuotes,
+            CheckCode::D301 => CheckKind::UsesRPrefixForBackslashedContent,
             CheckCode::D400 => CheckKind::EndsInPeriod,
             CheckCode::D402 => CheckKind::NoSignature,
             CheckCode::D403 => CheckKind::FirstLineCapitalized,
@@ -1289,6 +1307,7 @@ impl CheckCode {
             CheckCode::D214 => CheckCategory::Pydocstyle,
             CheckCode::D215 => CheckCategory::Pydocstyle,
             CheckCode::D300 => CheckCategory::Pydocstyle,
+            CheckCode::D301 => CheckCategory::Pydocstyle,
             CheckCode::D400 => CheckCategory::Pydocstyle,
             CheckCode::D402 => CheckCategory::Pydocstyle,
             CheckCode::D403 => CheckCategory::Pydocstyle,
@@ -1359,11 +1378,13 @@ impl CheckCode {
             CheckCode::F706 => CheckCategory::Pyflakes,
             CheckCode::F707 => CheckCategory::Pyflakes,
             CheckCode::F722 => CheckCategory::Pyflakes,
+            CheckCode::F811 => CheckCategory::Pyflakes,
             CheckCode::F821 => CheckCategory::Pyflakes,
             CheckCode::F822 => CheckCategory::Pyflakes,
             CheckCode::F823 => CheckCategory::Pyflakes,
             CheckCode::F831 => CheckCategory::Pyflakes,
             CheckCode::F841 => CheckCategory::Pyflakes,
+            CheckCode::F842 => CheckCategory::Pyflakes,
             CheckCode::F901 => CheckCategory::Pyflakes,
             CheckCode::FBT001 => CheckCategory::Flake8BooleanTrap,
             CheckCode::FBT002 => CheckCategory::Flake8BooleanTrap,
@@ -1390,12 +1411,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,
@@ -1508,23 +1532,28 @@ impl CheckKind {
             CheckKind::TypeComparison => &CheckCode::E721,
             CheckKind::UndefinedExport(_) => &CheckCode::F822,
             CheckKind::UndefinedLocal(_) => &CheckCode::F823,
+            CheckKind::RedefinedWhileUnused(..) => &CheckCode::F811,
             CheckKind::UndefinedName(_) => &CheckCode::F821,
             CheckKind::UnusedImport(..) => &CheckCode::F401,
             CheckKind::UnusedVariable(_) => &CheckCode::F841,
+            CheckKind::UnusedAnnotation(_) => &CheckCode::F842,
             CheckKind::YieldOutsideFunction(_) => &CheckCode::F704,
             // pycodestyle warnings
             CheckKind::NoNewLineAtEndOfFile => &CheckCode::W292,
             CheckKind::InvalidEscapeSequence(_) => &CheckCode::W605,
             // pylint
-            CheckKind::UselessImportAlias => &CheckCode::PLC0414,
-            CheckKind::MisplacedComparisonConstant(..) => &CheckCode::PLC2201,
-            CheckKind::UnnecessaryDirectLambdaCall => &CheckCode::PLC3002,
             CheckKind::AwaitOutsideAsync => &CheckCode::PLE1142,
             CheckKind::ConsiderMergingIsinstance(..) => &CheckCode::PLR1701,
-            CheckKind::PropertyWithParameters => &CheckCode::PLR0206,
             CheckKind::ConsiderUsingFromImport(..) => &CheckCode::PLR0402,
+            CheckKind::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,
@@ -1680,6 +1709,7 @@ impl CheckKind {
             CheckKind::SectionUnderlineMatchesSectionLength(_) => &CheckCode::D409,
             CheckKind::SectionUnderlineNotOverIndented(_) => &CheckCode::D215,
             CheckKind::SkipDocstring => &CheckCode::D418,
+            CheckKind::UsesRPrefixForBackslashedContent => &CheckCode::D301,
             CheckKind::UsesTripleQuotes => &CheckCode::D300,
             // pep8-naming
             CheckKind::InvalidClassName(_) => &CheckCode::N801,
@@ -1846,6 +1876,9 @@ impl CheckKind {
             CheckKind::RaiseNotImplemented => {
                 "`raise NotImplemented` should be `raise NotImplementedError`".to_string()
             }
+            CheckKind::RedefinedWhileUnused(name, line) => {
+                format!("Redefinition of unused `{name}` from line {line}")
+            }
             CheckKind::ReturnOutsideFunction => {
                 "`return` statement outside of a function/method".to_string()
             }
@@ -1894,6 +1927,9 @@ impl CheckKind {
             CheckKind::UndefinedName(name) => {
                 format!("Undefined name `{name}`")
             }
+            CheckKind::UnusedAnnotation(name) => {
+                format!("Local variable `{name}` is annotated but never used")
+            }
             CheckKind::UnusedImport(name, ignore_init) => {
                 if *ignore_init {
                     format!(
@@ -1923,8 +1959,11 @@ impl CheckKind {
                 let types = types.join(", ");
                 format!("Merge these isinstance calls: `isinstance({obj}, ({types}))`")
             }
-            CheckKind::MisplacedComparisonConstant(comprison) => {
-                format!("Comparison should be {comprison}")
+            CheckKind::MisplacedComparisonConstant(comparison) => {
+                format!("Comparison should be {comparison}")
+            }
+            CheckKind::NonlocalWithoutBinding(name) => {
+                format!("Nonlocal name `{name}` found without binding")
             }
             CheckKind::UnnecessaryDirectLambdaCall => "Lambda expression called directly. Execute \
                                                        the expression inline instead."
@@ -1935,6 +1974,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()
             }
@@ -2332,6 +2377,9 @@ impl CheckKind {
             CheckKind::FirstLineCapitalized => {
                 "First word of the first line should be properly capitalized".to_string()
             }
+            CheckKind::UsesRPrefixForBackslashedContent => {
+                r#"Use r""" if any backslashes in a docstring"#.to_string()
+            }
             CheckKind::UsesTripleQuotes => r#"Use """triple double quotes""""#.to_string(),
             CheckKind::MultiLineSummaryFirstLine => {
                 "Multi-line docstring summary should start at the first line".to_string()
@@ -2627,6 +2675,7 @@ impl CheckKind {
                 | CheckKind::NotIsTest
                 | CheckKind::OneBlankLineAfterClass(..)
                 | CheckKind::OneBlankLineBeforeClass(..)
+                | CheckKind::PercentFormatExtraNamedArguments(..)
                 | CheckKind::PEP3120UnnecessaryCodingComment
                 | CheckKind::PPrintFound
                 | CheckKind::PrintFound
@@ -2639,6 +2688,7 @@ impl CheckKind {
                 | CheckKind::SectionUnderlineMatchesSectionLength(..)
                 | CheckKind::SectionUnderlineNotOverIndented(..)
                 | CheckKind::SetAttrWithConstant
+                | CheckKind::StringDotFormatExtraNamedArguments(..)
                 | CheckKind::SuperCallWithParameters
                 | CheckKind::TrueFalseComparison(..)
                 | CheckKind::TypeOfPrimitive(..)

src/checks_gen.rs

@@ -139,6 +139,7 @@ pub enum CheckCodePrefix {
     D3,
     D30,
     D300,
+    D301,
     D4,
     D40,
     D400,
@@ -243,6 +244,8 @@ pub enum CheckCodePrefix {
     F72,
     F722,
     F8,
+    F81,
+    F811,
     F82,
     F821,
     F822,
@@ -251,6 +254,7 @@ pub enum CheckCodePrefix {
     F831,
     F84,
     F841,
+    F842,
     F9,
     F90,
     F901,
@@ -311,6 +315,11 @@ pub enum CheckCodePrefix {
     PLC300,
     PLC3002,
     PLE,
+    PLE0,
+    PLE01,
+    PLE011,
+    PLE0117,
+    PLE0118,
     PLE1,
     PLE11,
     PLE114,
@@ -334,6 +343,9 @@ pub enum CheckCodePrefix {
     PLW01,
     PLW012,
     PLW0120,
+    PLW06,
+    PLW060,
+    PLW0602,
     Q,
     Q0,
     Q00,
@@ -759,6 +771,7 @@ impl CheckCodePrefix {
                 CheckCode::D214,
                 CheckCode::D215,
                 CheckCode::D300,
+                CheckCode::D301,
                 CheckCode::D400,
                 CheckCode::D402,
                 CheckCode::D403,
@@ -861,9 +874,10 @@ impl CheckCodePrefix {
             CheckCodePrefix::D213 => vec![CheckCode::D213],
             CheckCodePrefix::D214 => vec![CheckCode::D214],
             CheckCodePrefix::D215 => vec![CheckCode::D215],
-            CheckCodePrefix::D3 => vec![CheckCode::D300],
-            CheckCodePrefix::D30 => vec![CheckCode::D300],
+            CheckCodePrefix::D3 => vec![CheckCode::D300, CheckCode::D301],
+            CheckCodePrefix::D30 => vec![CheckCode::D300, CheckCode::D301],
             CheckCodePrefix::D300 => vec![CheckCode::D300],
+            CheckCodePrefix::D301 => vec![CheckCode::D301],
             CheckCodePrefix::D4 => vec![
                 CheckCode::D400,
                 CheckCode::D402,
@@ -1026,11 +1040,13 @@ impl CheckCodePrefix {
                 CheckCode::F706,
                 CheckCode::F707,
                 CheckCode::F722,
+                CheckCode::F811,
                 CheckCode::F821,
                 CheckCode::F822,
                 CheckCode::F823,
                 CheckCode::F831,
                 CheckCode::F841,
+                CheckCode::F842,
                 CheckCode::F901,
             ],
             CheckCodePrefix::F4 => vec![
@@ -1158,20 +1174,25 @@ impl CheckCodePrefix {
             CheckCodePrefix::F72 => vec![CheckCode::F722],
             CheckCodePrefix::F722 => vec![CheckCode::F722],
             CheckCodePrefix::F8 => vec![
+                CheckCode::F811,
                 CheckCode::F821,
                 CheckCode::F822,
                 CheckCode::F823,
                 CheckCode::F831,
                 CheckCode::F841,
+                CheckCode::F842,
             ],
+            CheckCodePrefix::F81 => vec![CheckCode::F811],
+            CheckCodePrefix::F811 => vec![CheckCode::F811],
             CheckCodePrefix::F82 => vec![CheckCode::F821, CheckCode::F822, CheckCode::F823],
             CheckCodePrefix::F821 => vec![CheckCode::F821],
             CheckCodePrefix::F822 => vec![CheckCode::F822],
             CheckCodePrefix::F823 => vec![CheckCode::F823],
             CheckCodePrefix::F83 => vec![CheckCode::F831],
             CheckCodePrefix::F831 => vec![CheckCode::F831],
-            CheckCodePrefix::F84 => vec![CheckCode::F841],
+            CheckCodePrefix::F84 => vec![CheckCode::F841, CheckCode::F842],
             CheckCodePrefix::F841 => vec![CheckCode::F841],
+            CheckCodePrefix::F842 => vec![CheckCode::F842],
             CheckCodePrefix::F9 => vec![CheckCode::F901],
             CheckCodePrefix::F90 => vec![CheckCode::F901],
             CheckCodePrefix::F901 => vec![CheckCode::F901],
@@ -1330,7 +1351,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],
@@ -1354,11 +1382,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,
@@ -1929,6 +1960,7 @@ impl CheckCodePrefix {
             CheckCodePrefix::D3 => SuffixLength::One,
             CheckCodePrefix::D30 => SuffixLength::Two,
             CheckCodePrefix::D300 => SuffixLength::Three,
+            CheckCodePrefix::D301 => SuffixLength::Three,
             CheckCodePrefix::D4 => SuffixLength::One,
             CheckCodePrefix::D40 => SuffixLength::Two,
             CheckCodePrefix::D400 => SuffixLength::Three,
@@ -2033,6 +2065,8 @@ impl CheckCodePrefix {
             CheckCodePrefix::F72 => SuffixLength::Two,
             CheckCodePrefix::F722 => SuffixLength::Three,
             CheckCodePrefix::F8 => SuffixLength::One,
+            CheckCodePrefix::F81 => SuffixLength::Two,
+            CheckCodePrefix::F811 => SuffixLength::Three,
             CheckCodePrefix::F82 => SuffixLength::Two,
             CheckCodePrefix::F821 => SuffixLength::Three,
             CheckCodePrefix::F822 => SuffixLength::Three,
@@ -2041,6 +2075,7 @@ impl CheckCodePrefix {
             CheckCodePrefix::F831 => SuffixLength::Three,
             CheckCodePrefix::F84 => SuffixLength::Two,
             CheckCodePrefix::F841 => SuffixLength::Three,
+            CheckCodePrefix::F842 => SuffixLength::Three,
             CheckCodePrefix::F9 => SuffixLength::One,
             CheckCodePrefix::F90 => SuffixLength::Two,
             CheckCodePrefix::F901 => SuffixLength::Three,
@@ -2101,6 +2136,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,
@@ -2124,6 +2164,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,

src/cli.rs

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

src/docstrings/constants.rs

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

src/docstrings/definition.rs

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

src/docstrings/sections.rs

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

src/eradicate/detection.rs

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

src/flake8_print/plugins/print_call.rs

@@ -19,24 +19,14 @@ pub fn print_call(checker: &mut Checker, expr: &Expr, func: &Expr) {
     };
 
     if checker.patch(check.kind.code()) {
-        let context = checker.binding_context();
-        if matches!(
-            checker.parents[context.defined_by].node,
-            StmtKind::Expr { .. }
-        ) {
-            let deleted: Vec<&Stmt> = checker
-                .deletions
-                .iter()
-                .map(|index| checker.parents[*index])
-                .collect();
-            match helpers::remove_stmt(
-                checker.parents[context.defined_by],
-                context.defined_in.map(|index| checker.parents[index]),
-                &deleted,
-            ) {
+        let defined_by = checker.current_parent();
+        let defined_in = checker.current_grandparent();
+        if matches!(defined_by.0.node, StmtKind::Expr { .. }) {
+            let deleted: Vec<&Stmt> = checker.deletions.iter().map(|node| node.0).collect();
+            match helpers::remove_stmt(defined_by.0, defined_in.map(|node| node.0), &deleted) {
                 Ok(fix) => {
                     if fix.content.is_empty() || fix.content == "pass" {
-                        checker.deletions.insert(context.defined_by);
+                        checker.deletions.insert(defined_by.clone());
                     }
                     check.amend(fix);
                 }

src/flake8_return/visitor.rs

@@ -18,6 +18,8 @@ pub struct Stack<'a> {
 #[derive(Default)]
 pub struct ReturnVisitor<'a> {
     pub stack: Stack<'a>,
+    // If we're in an f-string, the location of the defining expression.
+    in_f_string: Option<Location>,
 }
 
 impl<'a> ReturnVisitor<'a> {
@@ -34,7 +36,7 @@ impl<'a> ReturnVisitor<'a> {
                     .assigns
                     .entry(id)
                     .or_insert_with(Vec::new)
-                    .push(expr.location);
+                    .push(self.in_f_string.unwrap_or(expr.location));
                 return;
             }
             _ => {}
@@ -70,7 +72,7 @@ impl<'a> Visitor<'a> for ReturnVisitor<'a> {
                         .refs
                         .entry(id)
                         .or_insert_with(Vec::new)
-                        .push(value.location);
+                        .push(self.in_f_string.unwrap_or(value.location));
                 }
 
                 visitor::walk_expr(self, value);
@@ -111,7 +113,13 @@ impl<'a> Visitor<'a> for ReturnVisitor<'a> {
                     .refs
                     .entry(id)
                     .or_insert_with(Vec::new)
-                    .push(expr.location);
+                    .push(self.in_f_string.unwrap_or(expr.location));
+            }
+            ExprKind::JoinedStr { .. } => {
+                let prev_in_f_string = self.in_f_string;
+                self.in_f_string = Some(expr.location);
+                visitor::walk_expr(self, expr);
+                self.in_f_string = prev_in_f_string;
             }
             _ => visitor::walk_expr(self, expr),
         }

src/flake8_unused_arguments/plugins.rs

@@ -17,12 +17,13 @@ use crate::{visibility, Check};
 fn function(
     argumentable: &Argumentable,
     args: &Arguments,
-    bindings: &FxHashMap<&str, Binding>,
+    values: &FxHashMap<&str, usize>,
+    bindings: &[Binding],
     dummy_variable_rgx: &Regex,
 ) -> Vec<Check> {
     let mut checks: Vec<Check> = vec![];
     for arg_name in collect_arg_names(args) {
-        if let Some(binding) = bindings.get(arg_name) {
+        if let Some(binding) = values.get(arg_name).map(|index| &bindings[*index]) {
             if binding.used.is_none()
                 && matches!(binding.kind, BindingKind::Argument)
                 && !dummy_variable_rgx.is_match(arg_name)
@@ -41,7 +42,8 @@ fn function(
 fn method(
     argumentable: &Argumentable,
     args: &Arguments,
-    bindings: &FxHashMap<&str, Binding>,
+    values: &FxHashMap<&str, usize>,
+    bindings: &[Binding],
     dummy_variable_rgx: &Regex,
 ) -> Vec<Check> {
     let mut checks: Vec<Check> = vec![];
@@ -54,7 +56,10 @@ fn method(
         .chain(iter::once::<Option<&Arg>>(args.vararg.as_deref()).flatten())
         .chain(iter::once::<Option<&Arg>>(args.kwarg.as_deref()).flatten())
     {
-        if let Some(binding) = bindings.get(&arg.node.arg.as_str()) {
+        if let Some(binding) = values
+            .get(&arg.node.arg.as_str())
+            .map(|index| &bindings[*index])
+        {
             if binding.used.is_none()
                 && matches!(binding.kind, BindingKind::Argument)
                 && !dummy_variable_rgx.is_match(arg.node.arg.as_str())
@@ -70,7 +75,12 @@ fn method(
 }
 
 /// ARG001, ARG002, ARG003, ARG004, ARG005
-pub fn unused_arguments(checker: &Checker, parent: &Scope, scope: &Scope) -> Vec<Check> {
+pub fn unused_arguments(
+    checker: &Checker,
+    parent: &Scope,
+    scope: &Scope,
+    bindings: &[Binding],
+) -> Vec<Check> {
     match &scope.kind {
         ScopeKind::Function(FunctionDef {
             name,
@@ -98,6 +108,7 @@ pub fn unused_arguments(checker: &Checker, parent: &Scope, scope: &Scope) -> Vec
                             &Argumentable::Function,
                             args,
                             &scope.values,
+                            bindings,
                             &checker.settings.dummy_variable_rgx,
                         )
                     } else {
@@ -117,6 +128,7 @@ pub fn unused_arguments(checker: &Checker, parent: &Scope, scope: &Scope) -> Vec
                             &Argumentable::Method,
                             args,
                             &scope.values,
+                            bindings,
                             &checker.settings.dummy_variable_rgx,
                         )
                     } else {
@@ -136,6 +148,7 @@ pub fn unused_arguments(checker: &Checker, parent: &Scope, scope: &Scope) -> Vec
                             &Argumentable::ClassMethod,
                             args,
                             &scope.values,
+                            bindings,
                             &checker.settings.dummy_variable_rgx,
                         )
                     } else {
@@ -155,6 +168,7 @@ pub fn unused_arguments(checker: &Checker, parent: &Scope, scope: &Scope) -> Vec
                             &Argumentable::StaticMethod,
                             args,
                             &scope.values,
+                            bindings,
                             &checker.settings.dummy_variable_rgx,
                         )
                     } else {
@@ -173,6 +187,7 @@ pub fn unused_arguments(checker: &Checker, parent: &Scope, scope: &Scope) -> Vec
                     &Argumentable::Lambda,
                     args,
                     &scope.values,
+                    bindings,
                     &checker.settings.dummy_variable_rgx,
                 )
             } else {

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,
                 ));

src/isort/settings.rs

@@ -32,11 +32,16 @@ pub struct Options {
                 test_id as test_id
             )
             ```
+
+            Note that this setting is only effective when combined with `combine-as-imports = true`.
+            When `combine-as-imports` isn't enabled, every aliased `import from` will be given its
+            own line, in which case, wrapping is not necessary.
         "#,
         default = r#"false"#,
         value_type = "bool",
         example = r#"
             force-wrap-aliases = true
+            combine-as-imports = true
         "#
     )]
     pub force_wrap_aliases: Option<bool>,

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.

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 {

src/pydocstyle/helpers.rs

@@ -1,17 +1,23 @@
-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 {
+    for pattern in constants::TRIPLE_QUOTE_PREFIXES {
+        if contents.starts_with(pattern) {
+            return &contents[pattern.len()..contents.len() - 3];
+        }
+    }
+    for pattern in constants::SINGLE_QUOTE_PREFIXES {
+        if contents.starts_with(pattern) {
+            return &contents[pattern.len()..contents.len() - 1];
+        }
+    }
+    unreachable!("Expected docstring to start with a valid triple- or single-quote prefix")
+}
 
 /// 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()
-        .map(str::to_lowercase)
-    {
+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)

src/pydocstyle/mod.rs

@@ -1,4 +1,4 @@
-mod helpers;
+pub mod helpers;
 pub mod plugins;
 
 #[cfg(test)]
@@ -37,6 +37,7 @@ mod tests {
     #[test_case(CheckCode::D214, Path::new("sections.py"); "D214")]
     #[test_case(CheckCode::D215, Path::new("sections.py"); "D215")]
     #[test_case(CheckCode::D300, Path::new("D.py"); "D300")]
+    #[test_case(CheckCode::D301, Path::new("D.py"); "D301")]
     #[test_case(CheckCode::D400, Path::new("D.py"); "D400_0")]
     #[test_case(CheckCode::D400, Path::new("D400.py"); "D400_1")]
     #[test_case(CheckCode::D402, Path::new("D.py"); "D402")]

src/pydocstyle/snapshots/ruff__pydocstyle__tests__D301_D.py.snap

@@ -0,0 +1,29 @@
+---
+source: src/pydocstyle/mod.rs
+expression: checks
+---
+- kind: UsesRPrefixForBackslashedContent
+  location:
+    row: 328
+    column: 4
+  end_location:
+    row: 328
+    column: 16
+  fix: ~
+- kind: UsesRPrefixForBackslashedContent
+  location:
+    row: 333
+    column: 4
+  end_location:
+    row: 333
+    column: 20
+  fix: ~
+- kind: UsesRPrefixForBackslashedContent
+  location:
+    row: 338
+    column: 4
+  end_location:
+    row: 338
+    column: 21
+  fix: ~
+

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::{BindingKind, Range, Scope, ScopeKind};
+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> {
@@ -366,12 +30,12 @@ pub fn if_tuple(test: &Expr, location: Range) -> Option<Check> {
 }
 
 /// F821
-pub fn undefined_local(scopes: &[&Scope], name: &str) -> Option<Check> {
+pub fn undefined_local(name: &str, scopes: &[&Scope], bindings: &[Binding]) -> Option<Check> {
     let current = &scopes.last().expect("No current scope found");
     if matches!(current.kind, ScopeKind::Function(_)) && !current.values.contains_key(name) {
         for scope in scopes.iter().rev().skip(1) {
             if matches!(scope.kind, ScopeKind::Function(_) | ScopeKind::Module) {
-                if let Some(binding) = scope.values.get(name) {
+                if let Some(binding) = scope.values.get(name).map(|index| &bindings[*index]) {
                     if let Some((scope_id, location)) = binding.used {
                         if scope_id == current.id {
                             return Some(Check::new(
@@ -388,23 +52,31 @@ pub fn undefined_local(scopes: &[&Scope], name: &str) -> Option<Check> {
 }
 
 /// F841
-pub fn unused_variables(scope: &Scope, dummy_variable_rgx: &Regex) -> Vec<Check> {
+pub fn unused_variable(
+    scope: &Scope,
+    bindings: &[Binding],
+    dummy_variable_rgx: &Regex,
+) -> Vec<Check> {
     let mut checks: Vec<Check> = vec![];
 
     if scope.uses_locals && matches!(scope.kind, ScopeKind::Function(..)) {
         return checks;
     }
 
-    for (&name, binding) in &scope.values {
+    for (name, binding) in scope
+        .values
+        .iter()
+        .map(|(name, index)| (name, &bindings[*index]))
+    {
         if binding.used.is_none()
             && matches!(binding.kind, BindingKind::Assignment)
             && !dummy_variable_rgx.is_match(name)
-            && name != "__tracebackhide__"
-            && name != "__traceback_info__"
-            && name != "__traceback_supplement__"
+            && name != &"__tracebackhide__"
+            && name != &"__traceback_info__"
+            && name != &"__traceback_supplement__"
         {
             checks.push(Check::new(
-                CheckKind::UnusedVariable(name.to_string()),
+                CheckKind::UnusedVariable((*name).to_string()),
                 binding.range,
             ));
         }
@@ -413,6 +85,31 @@ pub fn unused_variables(scope: &Scope, dummy_variable_rgx: &Regex) -> Vec<Check>
     checks
 }
 
+/// F842
+pub fn unused_annotation(
+    scope: &Scope,
+    bindings: &[Binding],
+    dummy_variable_rgx: &Regex,
+) -> Vec<Check> {
+    let mut checks: Vec<Check> = vec![];
+    for (name, binding) in scope
+        .values
+        .iter()
+        .map(|(name, index)| (name, &bindings[*index]))
+    {
+        if binding.used.is_none()
+            && matches!(binding.kind, BindingKind::Annotation)
+            && !dummy_variable_rgx.is_match(name)
+        {
+            checks.push(Check::new(
+                CheckKind::UnusedAnnotation((*name).to_string()),
+                binding.range,
+            ));
+        }
+    }
+    checks
+}
+
 /// F707
 pub fn default_except_not_last(handlers: &[Excepthandler]) -> Option<Check> {
     for (idx, handler) in handlers.iter().enumerate() {
@@ -546,12 +243,13 @@ pub fn starred_expressions(
 }
 
 /// F701
-pub fn break_outside_loop(stmt: &Stmt, parents: &[&Stmt], parent_stack: &[usize]) -> Option<Check> {
+pub fn break_outside_loop<'a>(
+    stmt: &'a Stmt,
+    parents: &mut impl Iterator<Item = &'a Stmt>,
+) -> Option<Check> {
     let mut allowed: bool = false;
-    let mut parent = stmt;
-    for index in parent_stack.iter().rev() {
-        let child = parent;
-        parent = parents[*index];
+    let mut child = stmt;
+    for parent in parents {
         match &parent.node {
             StmtKind::For { orelse, .. }
             | StmtKind::AsyncFor { orelse, .. }
@@ -561,7 +259,6 @@ pub fn break_outside_loop(stmt: &Stmt, parents: &[&Stmt], parent_stack: &[usize]
                     break;
                 }
             }
-
             StmtKind::FunctionDef { .. }
             | StmtKind::AsyncFunctionDef { .. }
             | StmtKind::ClassDef { .. } => {
@@ -569,6 +266,7 @@ pub fn break_outside_loop(stmt: &Stmt, parents: &[&Stmt], parent_stack: &[usize]
             }
             _ => {}
         }
+        child = parent;
     }
 
     if allowed {
@@ -582,16 +280,13 @@ pub fn break_outside_loop(stmt: &Stmt, parents: &[&Stmt], parent_stack: &[usize]
 }
 
 /// F702
-pub fn continue_outside_loop(
-    stmt: &Stmt,
-    parents: &[&Stmt],
-    parent_stack: &[usize],
+pub fn continue_outside_loop<'a>(
+    stmt: &'a Stmt,
+    parents: &mut impl Iterator<Item = &'a Stmt>,
 ) -> Option<Check> {
     let mut allowed: bool = false;
-    let mut parent = stmt;
-    for index in parent_stack.iter().rev() {
-        let child = parent;
-        parent = parents[*index];
+    let mut child = stmt;
+    for parent in parents {
         match &parent.node {
             StmtKind::For { orelse, .. }
             | StmtKind::AsyncFor { orelse, .. }
@@ -601,7 +296,6 @@ pub fn continue_outside_loop(
                     break;
                 }
             }
-
             StmtKind::FunctionDef { .. }
             | StmtKind::AsyncFunctionDef { .. }
             | StmtKind::ClassDef { .. } => {
@@ -609,6 +303,7 @@ pub fn continue_outside_loop(
             }
             _ => {}
         }
+        child = parent;
     }
 
     if allowed {

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,
+    ))
+}

src/pyflakes/plugins/invalid_print_syntax.rs

@@ -1,6 +1,6 @@
 use rustpython_ast::{Expr, ExprKind};
 
-use crate::ast::types::{Binding, BindingKind, Range};
+use crate::ast::types::Range;
 use crate::check_ast::Checker;
 use crate::checks::{Check, CheckKind};
 
@@ -12,12 +12,7 @@ pub fn invalid_print_syntax(checker: &mut Checker, left: &Expr) {
     if id != "print" {
         return;
     }
-    let scope = checker.current_scope();
-    let Some(Binding {
-        kind: BindingKind::Builtin,
-        ..
-    }) = scope.values.get("print") else
-    {
+    if !checker.is_builtin("print") {
         return;
     };
     checker.add_check(Check::new(

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;

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,
+        ));
+    }
+}

src/pyflakes/snapshots/ruff__pyflakes__tests__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
 

src/pyflakes/snapshots/ruff__pyflakes__tests__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
 

src/pyflakes/snapshots/ruff__pyflakes__tests__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
 

src/pyflakes/snapshots/ruff__pyflakes__tests__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: ~
 

src/pyflakes/snapshots/ruff__pyflakes__tests__F811_F811_0.py.snap

@@ -0,0 +1,16 @@
+---
+source: src/pyflakes/mod.rs
+expression: checks
+---
+- kind:
+    RedefinedWhileUnused:
+      - bar
+      - 6
+  location:
+    row: 10
+    column: 0
+  end_location:
+    row: 12
+    column: 0
+  fix: ~
+

src/pyflakes/snapshots/ruff__pyflakes__tests__F811_F811_1.py.snap

@@ -0,0 +1,16 @@
+---
+source: src/pyflakes/mod.rs
+expression: checks
+---
+- kind:
+    RedefinedWhileUnused:
+      - FU
+      - 1
+  location:
+    row: 1
+    column: 17
+  end_location:
+    row: 1
+    column: 26
+  fix: ~
+

src/pyflakes/snapshots/ruff__pyflakes__tests__F811_F811_10.py.snap

@@ -0,0 +1,6 @@
+---
+source: src/pyflakes/mod.rs
+expression: checks
+---
+[]
+

src/pyflakes/snapshots/ruff__pyflakes__tests__F811_F811_11.py.snap

@@ -0,0 +1,6 @@
+---
+source: src/pyflakes/mod.rs
+expression: checks
+---
+[]
+

src/pyflakes/snapshots/ruff__pyflakes__tests__F811_F811_12.py.snap

@@ -0,0 +1,16 @@
+---
+source: src/pyflakes/mod.rs
+expression: checks
+---
+- kind:
+    RedefinedWhileUnused:
+      - mixer
+      - 2
+  location:
+    row: 6
+    column: 19
+  end_location:
+    row: 6
+    column: 24
+  fix: ~
+

src/pyflakes/snapshots/ruff__pyflakes__tests__F811_F811_13.py.snap

@@ -0,0 +1,6 @@
+---
+source: src/pyflakes/mod.rs
+expression: checks
+---
+[]
+

src/pyflakes/snapshots/ruff__pyflakes__tests__F811_F811_14.py.snap

@@ -0,0 +1,6 @@
+---
+source: src/pyflakes/mod.rs
+expression: checks
+---
+[]
+

src/pyflakes/snapshots/ruff__pyflakes__tests__F811_F811_15.py.snap

@@ -0,0 +1,16 @@
+---
+source: src/pyflakes/mod.rs
+expression: checks
+---
+- kind:
+    RedefinedWhileUnused:
+      - fu
+      - 1
+  location:
+    row: 4
+    column: 0
+  end_location:
+    row: 6
+    column: 0
+  fix: ~
+

src/pyflakes/snapshots/ruff__pyflakes__tests__F811_F811_16.py.snap

@@ -0,0 +1,16 @@
+---
+source: src/pyflakes/mod.rs
+expression: checks
+---
+- kind:
+    RedefinedWhileUnused:
+      - fu
+      - 3
+  location:
+    row: 8
+    column: 8
+  end_location:
+    row: 10
+    column: 0
+  fix: ~
+

src/pyflakes/snapshots/ruff__pyflakes__tests__F811_F811_17.py.snap

@@ -0,0 +1,27 @@
+---
+source: src/pyflakes/mod.rs
+expression: checks
+---
+- kind:
+    RedefinedWhileUnused:
+      - fu
+      - 2
+  location:
+    row: 6
+    column: 11
+  end_location:
+    row: 6
+    column: 13
+  fix: ~
+- kind:
+    RedefinedWhileUnused:
+      - fu
+      - 6
+  location:
+    row: 9
+    column: 8
+  end_location:
+    row: 11
+    column: 0
+  fix: ~
+

src/pyflakes/snapshots/ruff__pyflakes__tests__F811_F811_18.py.snap

@@ -0,0 +1,6 @@
+---
+source: src/pyflakes/mod.rs
+expression: checks
+---
+[]
+

src/pyflakes/snapshots/ruff__pyflakes__tests__F811_F811_19.py.snap

@@ -0,0 +1,6 @@
+---
+source: src/pyflakes/mod.rs
+expression: checks
+---
+[]
+

src/pyflakes/snapshots/ruff__pyflakes__tests__F811_F811_2.py.snap

@@ -0,0 +1,16 @@
+---
+source: src/pyflakes/mod.rs
+expression: checks
+---
+- kind:
+    RedefinedWhileUnused:
+      - FU
+      - 1
+  location:
+    row: 1
+    column: 26
+  end_location:
+    row: 1
+    column: 35
+  fix: ~
+

src/pyflakes/snapshots/ruff__pyflakes__tests__F811_F811_20.py.snap

@@ -0,0 +1,6 @@
+---
+source: src/pyflakes/mod.rs
+expression: checks
+---
+[]
+

src/pyflakes/snapshots/ruff__pyflakes__tests__F811_F811_3.py.snap

@@ -0,0 +1,16 @@
+---
+source: src/pyflakes/mod.rs
+expression: checks
+---
+- kind:
+    RedefinedWhileUnused:
+      - fu
+      - 1
+  location:
+    row: 1
+    column: 11
+  end_location:
+    row: 1
+    column: 13
+  fix: ~
+

src/pyflakes/snapshots/ruff__pyflakes__tests__F811_F811_4.py.snap

@@ -0,0 +1,16 @@
+---
+source: src/pyflakes/mod.rs
+expression: checks
+---
+- kind:
+    RedefinedWhileUnused:
+      - fu
+      - 1
+  location:
+    row: 1
+    column: 11
+  end_location:
+    row: 1
+    column: 13
+  fix: ~
+

src/pyflakes/snapshots/ruff__pyflakes__tests__F811_F811_5.py.snap

@@ -0,0 +1,16 @@
+---
+source: src/pyflakes/mod.rs
+expression: checks
+---
+- kind:
+    RedefinedWhileUnused:
+      - fu
+      - 1
+  location:
+    row: 1
+    column: 12
+  end_location:
+    row: 1
+    column: 14
+  fix: ~
+

src/pyflakes/snapshots/ruff__pyflakes__tests__F811_F811_6.py.snap

@@ -0,0 +1,16 @@
+---
+source: src/pyflakes/mod.rs
+expression: checks
+---
+- kind:
+    RedefinedWhileUnused:
+      - os
+      - 5
+  location:
+    row: 6
+    column: 11
+  end_location:
+    row: 6
+    column: 13
+  fix: ~
+

src/pyflakes/snapshots/ruff__pyflakes__tests__F811_F811_7.py.snap

@@ -0,0 +1,6 @@
+---
+source: src/pyflakes/mod.rs
+expression: checks
+---
+[]
+

src/pyflakes/snapshots/ruff__pyflakes__tests__F811_F811_8.py.snap

@@ -0,0 +1,16 @@
+---
+source: src/pyflakes/mod.rs
+expression: checks
+---
+- kind:
+    RedefinedWhileUnused:
+      - os
+      - 4
+  location:
+    row: 5
+    column: 11
+  end_location:
+    row: 5
+    column: 13
+  fix: ~
+

src/pyflakes/snapshots/ruff__pyflakes__tests__F811_F811_9.py.snap

@@ -0,0 +1,6 @@
+---
+source: src/pyflakes/mod.rs
+expression: checks
+---
+[]
+

src/pyflakes/snapshots/ruff__pyflakes__tests__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

src/pyflakes/snapshots/ruff__pyflakes__tests__F842_F842.py.snap

@@ -0,0 +1,23 @@
+---
+source: src/pyflakes/mod.rs
+expression: checks
+---
+- kind:
+    UnusedAnnotation: name
+  location:
+    row: 2
+    column: 4
+  end_location:
+    row: 2
+    column: 8
+  fix: ~
+- kind:
+    UnusedAnnotation: age
+  location:
+    row: 3
+    column: 4
+  end_location:
+    row: 3
+    column: 7
+  fix: ~
+