Bump version to 0.0.144

.pre-commit-config.yaml

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

Cargo.lock

@@ -290,6 +290,36 @@ dependencies = [
  "termcolor",
 ]
 
+[[package]]
+name = "clap_complete"
+version = "4.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b7b3c9eae0de7bf8e3f904a5e40612b21fb2e2e566456d177809a48b892d24da"
+dependencies = [
+ "clap 4.0.22",
+]
+
+[[package]]
+name = "clap_complete_command"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4160b4a4f72ef58bd766bad27c09e6ef1cc9d82a22f6a0f55d152985a4a48e31"
+dependencies = [
+ "clap 4.0.22",
+ "clap_complete",
+ "clap_complete_fig",
+]
+
+[[package]]
+name = "clap_complete_fig"
+version = "4.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "46b30e010e669cd021e5004f3be26cff6b7c08d2a8a0d65b48d43a8cc0efd6c3"
+dependencies = [
+ "clap 4.0.22",
+ "clap_complete",
+]
+
 [[package]]
 name = "clap_derive"
 version = "4.0.21"
@@ -670,7 +700,7 @@ checksum = "0ce7134b9999ecaf8bcd65542e436736ef32ddca1b3e06094cb6ec5755203b80"
 
 [[package]]
 name = "flake8-to-ruff"
-version = "0.0.141-dev.0"
+version = "0.0.144-dev.0"
 dependencies = [
  "anyhow",
  "clap 4.0.22",
@@ -1775,7 +1805,7 @@ dependencies = [
 
 [[package]]
 name = "ruff"
-version = "0.0.141"
+version = "0.0.144"
 dependencies = [
  "annotate-snippets 0.9.1",
  "anyhow",
@@ -1786,6 +1816,7 @@ dependencies = [
  "cachedir",
  "chrono",
  "clap 4.0.22",
+ "clap_complete_command",
  "clearscreen",
  "colored",
  "common-path",
@@ -1825,7 +1856,7 @@ dependencies = [
 
 [[package]]
 name = "ruff_dev"
-version = "0.0.141"
+version = "0.0.144"
 dependencies = [
  "anyhow",
  "clap 4.0.22",

Cargo.toml

@@ -6,7 +6,7 @@ members = [
 
 [package]
 name = "ruff"
-version = "0.0.141"
+version = "0.0.144"
 edition = "2021"
 rust-version = "1.65.0"
 
@@ -22,6 +22,7 @@ bitflags = { version = "1.3.2" }
 cachedir = { version = "0.3.0" }
 chrono = { version = "0.4.21", default-features = false, features = ["clock"] }
 clap = { version = "4.0.1", features = ["derive"] }
+clap_complete_command = "0.4.0"
 colored = { version = "2.0.0" }
 common-path = { version = "1.0.0" }
 dirs = { version = "4.0.0" }

README.md

@@ -20,10 +20,9 @@ An extremely fast Python linter, written in Rust.
 - 🤝  Python 3.10 compatibility
 - 🛠️  `pyproject.toml` support
 - 📦  Built-in caching, to avoid re-analyzing unchanged files
-- 🔧  `--fix` support, for automatic error correction (e.g., automatically remove unused imports)
-- 👀  `--watch` support, for continuous file monitoring
+- 🔧  Autofix support, for automatic error correction (e.g., automatically remove unused imports)
 - ⚖️  [Near-parity](#how-does-ruff-compare-to-flake8) with the built-in Flake8 rule set
-- 🔌  Native re-implementations of popular Flake8 plugins, like [`flake8-docstrings`](https://pypi.org/project/flake8-docstrings/) ([`pydocstyle`](https://pypi.org/project/pydocstyle/))
+- 🔌  Native re-implementations of popular Flake8 plugins, like [`flake8-bugbear`](https://pypi.org/project/flake8-bugbear/)
 
 Ruff aims to be orders of magnitude faster than alternative tools while integrating more
 functionality behind a single, common interface. Ruff can be used to replace Flake8 (plus a variety
@@ -32,7 +31,7 @@ of plugins), [`isort`](https://pypi.org/project/isort/), [`pydocstyle`](https://
 and [`autoflake`](https://pypi.org/project/autoflake/) all while executing tens or hundreds of times
 faster than any individual tool.
 
-Ruff is actively developed and used in major open-source projects like:
+Ruff is extremely actively developed and used in major open-source projects like:
 
 - [FastAPI](https://github.com/tiangolo/fastapi)
 - [Bokeh](https://github.com/bokeh/bokeh)
@@ -43,6 +42,26 @@ Ruff is actively developed and used in major open-source projects like:
 
 Read the [launch blog post](https://notes.crmarsh.com/python-tooling-could-be-much-much-faster).
 
+## Testimonials
+
+[**Sebastián Ramírez**](https://twitter.com/tiangolo/status/1591912354882764802), creator
+of [FastAPI](https://github.com/tiangolo/fastapi):
+
+> Ruff is so fast that sometimes I add an intentional bug in the code just to confirm it's actually
+> running and checking the code.
+
+[**Bryan Van de Ven**](https://github.com/bokeh/bokeh/pull/12605), co-creator
+of [Bokeh](https://github.com/bokeh/bokeh/), original author
+of [Conda](https://docs.conda.io/en/latest/):
+
+> Ruff is ~150-200x faster than flake8 on my machine, scanning the whole repo takes ~0.2s instead of
+> ~20s. This is an enormous quality of life improvement for local dev. It's fast enough that I added
+> it as an actual commit hook, which is terrific.
+
+[**Tim Abbott**](https://github.com/charliermarsh/ruff/issues/465#issuecomment-1317400028), lead developer of [Zulip](https://github.com/zulip/zulip):
+
+> This is just ridiculously fast... `ruff` is amazing.
+
 ## Table of Contents
 
 1. [Installation and Usage](#installation-and-usage)
@@ -74,6 +93,7 @@ Read the [launch blog post](https://notes.crmarsh.com/python-tooling-could-be-mu
 1. [Development](#development)
 1. [Releases](#releases)
 1. [Benchmarks](#benchmarks)
+1. [Reference](#reference)
 1. [License](#license)
 1. [Contributing](#contributing)
 
@@ -81,12 +101,18 @@ Read the [launch blog post](https://notes.crmarsh.com/python-tooling-could-be-mu
 
 ### Installation
 
-Available as [`ruff`](https://pypi.org/project/ruff/) on PyPI:
+Ruff is available as [`ruff`](https://pypi.org/project/ruff/) on PyPI:
 
 ```shell
 pip install ruff
 ```
 
+If you're a **macOS Homebrew** or a **Linuxbrew** user, you can also install `ruff` via Homebrew:
+
+```shell
+brew install ruff
+```
+
 ### Usage
 
 To run Ruff, try any of the following:
@@ -108,7 +134,7 @@ Ruff also works with [pre-commit](https://pre-commit.com):
 ```yaml
 repos:
   - repo: https://github.com/charliermarsh/ruff-pre-commit
-    rev: v0.0.141
+    rev: v0.0.144
     hooks:
       - id: ruff
 ```
@@ -118,8 +144,10 @@ _Note: prior to `v0.0.86`, `ruff-pre-commit` used `lint` (rather than `ruff`) as
 
 ## Configuration
 
-Ruff is configurable both via `pyproject.toml` and the command line. If left unspecified, the
-default configuration is equivalent to:
+Ruff is configurable both via `pyproject.toml` and the command line. For a full list of configurable
+options, see the [API reference](#reference).
+
+If left unspecified, the default configuration is equivalent to:
 
 ```toml
 [tool.ruff]
@@ -180,8 +208,10 @@ ignore = ["E501"]
 fix = true
 unfixable = ["F401"]
 
-# Ignore `E402` (import violations in any `__init__.py` file, and in `path/to/file.py`.
-per-file-ignores = {"__init__.py" = ["E402"], "path/to/file.py" = ["E402"]}
+# Ignore `E402` (import violations) in all `__init__.py` files, and in `path/to/file.py`.
+[tool.ruff.per-file-ignores]
+"__init__.py" = ["E402"]
+"path/to/file.py" = ["E402"]
 ```
 
 Plugin configurations should be expressed as subsections, e.g.:
@@ -195,7 +225,9 @@ select = ["E", "F", "Q"]
 docstring-quotes = "double"
 ```
 
-Alternatively, common configuration settings can be provided via the command-line:
+For a full list of configurable options, see the [API reference](#reference).
+
+Some common configuration settings can be provided via the command-line:
 
 ```shell
 ruff path/to/code/ --select F401 --select F403
@@ -272,17 +304,6 @@ Options:
           Print version information
 ```
 
-### Excluding files
-
-Exclusions are based on globs, and can be either:
-
-- Single-path patterns, like `.mypy_cache` (to exclude any directory named `.mypy_cache` in the
-  tree), `foo.py` (to exclude any file named `foo.py`), or `foo_*.py` (to exclude any file matching
-  `foo_*.py` ).
-- Relative patterns, like `directory/foo.py` (to exclude that specific file) or `directory/*.py`
-  (to exclude any Python files in `directory`). Note that these paths are relative to the
-  project root (e.g., the directory containing your `pyproject.toml`).
-
 ### Ignoring errors
 
 To omit a lint check entirely, add it to the "ignore" list via `--ignore` or `--extend-ignore`,
@@ -351,6 +372,15 @@ For more, see [Pyflakes](https://pypi.org/project/pyflakes/2.5.0/) on PyPI.
 | F405 | ImportStarUsage | `...` may be undefined, or defined from star imports: `...` |  |
 | F406 | ImportStarNotPermitted | `from ... import *` only allowed at module level |  |
 | F407 | FutureFeatureNotDefined | Future feature `...` is not defined |  |
+| 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): ... |  |
+| 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): ... |  |
 | F523 | StringDotFormatExtraPositionalArguments | '...'.format(...) has unused arguments at position(s): ... |  |
@@ -818,14 +848,13 @@ stylistic lint rules that are obviated by autoformatting.
 (Coming from Flake8? Try [`flake8-to-ruff`](https://pypi.org/project/flake8-to-ruff/) to
 automatically convert your existing configuration.)
 
-Ruff can be used as a (near) 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.
+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 is missing 9 rules related to `%` string formatting, 1 rule related
-to docstring parsing, and 1 rule related to redefined variables.
+Under those conditions, Ruff implements every rule in Flake8, with the exception of `F811`.
 
-Ruff re-implements some of the most popular Flake8 plugins and related code quality tools natively,
-including:
+Ruff also re-implements some of the most popular Flake8 plugins and related code quality tools
+natively,  including:
 
 - [`pydocstyle`](https://pypi.org/project/pydocstyle/)
 - [`pep8-naming`](https://pypi.org/project/pep8-naming/)
@@ -849,12 +878,12 @@ including:
 - [`pyupgrade`](https://pypi.org/project/pyupgrade/) (16/33)
 - [`autoflake`](https://pypi.org/project/autoflake/) (1/7)
 
-Beyond rule-set parity, Ruff suffers from the following limitations vis-à-vis Flake8:
+Beyond the rule set, Ruff suffers from the following limitations vis-à-vis Flake8:
 
 1. Ruff does not yet support a few Python 3.9 and 3.10 language features, including structural
    pattern matching and parenthesized context managers.
-2. Flake8 has a plugin architecture and supports writing custom lint rules. (To date, popular Flake8
-   plugins have been re-implemented within Ruff directly.)
+2. Flake8 has a plugin architecture and supports writing custom lint rules. (Instead, popular Flake8
+   plugins are re-implemented in Rust as part of Ruff itself.)
 
 ### Which tools does Ruff replace?
 
@@ -1157,6 +1186,614 @@ Summary
   389.73 ± 9.92 times faster than 'flake8 resources/test/cpython'
 ```
 
+## Reference
+
+### Options
+
+#### [`dummy_variable_rgx`](#dummy_variable_rgx)
+
+A regular expression used to identify "dummy" variables, or those which should be ignored when evaluating
+(e.g.) unused-variable checks.
+
+**Default value**: `"^(_+|(_+[a-zA-Z0-9_]*[a-zA-Z0-9]+?))$"` (matches `_`, `__`, and `_var`, but not `_var_`)
+
+**Type**: `Regex`
+
+**Example usage**:
+
+```toml
+[tool.ruff]
+# Only ignore variables named "_".
+dummy_variable_rgx = "^_$"
+```
+
+---
+
+#### [`exclude`](#exclude)
+
+A list of file patterns to exclude from linting.
+
+Exclusions are based on globs, and can be either:
+
+- Single-path patterns, like `.mypy_cache` (to exclude any directory named `.mypy_cache` in the
+  tree), `foo.py` (to exclude any file named `foo.py`), or `foo_*.py` (to exclude any file matching
+  `foo_*.py` ).
+- Relative patterns, like `directory/foo.py` (to exclude that specific file) or `directory/*.py`
+  (to exclude any Python files in `directory`). Note that these paths are relative to the
+  project root (e.g., the directory containing your `pyproject.toml`).
+
+Note that you'll typically want to use [`extend_exclude`](#extend_exclude) to modify the excluded
+paths.
+
+**Default value**: `[".bzr", ".direnv", ".eggs", ".git", ".hg", ".mypy_cache", ".nox", ".pants.d", ".ruff_cache", ".svn", ".tox", ".venv", "__pypackages__", "_build", "buck-out", "build", "dist", "node_modules", "venv"]`
+
+**Type**: `Vec<FilePattern>`
+
+**Example usage**:
+
+```toml
+[tool.ruff]
+exclude = [".venv"]
+````
+
+---
+
+#### [`extend_exclude`](#extend_exclude)
+
+A list of file patterns to omit from linting, in addition to those specified by `exclude`.
+
+**Default value**: `[]`
+
+**Type**: `Vec<FilePattern>`
+
+**Example usage**:
+
+```toml
+[tool.ruff]
+# In addition to the standard set of exclusions, omit all tests, plus a specific file.
+extend-exclude = ["tests", "src/bad.py"]
+````
+
+---
+
+#### [`ignore`](#ignore)
+
+A list of check code prefixes to ignore. Prefixes can specify exact checks (like `F841`), entire
+categories (like `F`), or anything in between.
+
+When breaking ties between enabled and disabled checks (via `select` and `ignore`, respectively),
+more specific prefixes override less specific prefixes.
+
+**Default value**: `[]`
+
+**Type**: `Vec<CheckCodePrefix>`
+
+**Example usage**:
+
+```toml
+[tool.ruff]
+# Skip unused variable checks (`F841`).
+ignore = ["F841"]
+```
+
+---
+
+#### [`extend_ignore`](#extend_ignore)
+
+A list of check code prefixes to ignore, in addition to those specified by `ignore`.
+
+**Default value**: `[]`
+
+**Type**: `Vec<CheckCodePrefix>`
+
+**Example usage**:
+
+```toml
+[tool.ruff]
+# Skip unused variable checks (`F841`).
+extend-ignore = ["F841"]
+```
+
+---
+
+#### [`select`](#select)
+
+A list of check code prefixes to enable. Prefixes can specify exact checks (like `F841`), entire
+categories (like `F`), or anything in between.
+
+When breaking ties between enabled and disabled checks (via `select` and `ignore`, respectively),
+more specific prefixes override less specific prefixes.
+
+**Default value**: `["E", "F"]`
+
+**Type**: `Vec<CheckCodePrefix>`
+
+**Example usage**:
+
+```toml
+[tool.ruff]
+# On top of the defaults (`E`, `F`), enable flake8-bugbear (`B`) and flake8-quotes (`Q`).
+select = ["E", "F", "B", "Q"]
+```
+
+---
+
+#### [`extend_select`](#extend_select)
+
+A list of check code prefixes to enable, in addition to those specified by `select`.
+
+**Default value**: `[]`
+
+**Type**: `Vec<CheckCodePrefix>`
+
+**Example usage**:
+
+```toml
+[tool.ruff]
+# On top of the default `select` (`E`, `F`), enable flake8-bugbear (`B`) and flake8-quotes (`Q`).
+extend-select = ["B", "Q"]
+```
+
+---
+
+#### [`fix`](#fix)
+
+Enable autofix behavior by-default when running `ruff` (overridden by the `--fix` and `--no-fix`
+command-line flags).
+
+**Default value**: `false`
+
+**Type**: `bool`
+
+**Example usage**:
+
+```toml
+[tool.ruff]
+fix = true
+```
+
+---
+
+#### [`fixable`](#fixable)
+
+A list of check code prefixes to consider autofix-able.
+
+**Default value**: `["A", "ANN", "B", "BLE", "C", "D", "E", "F", "FBT", "I", "M", "N", "Q", "RUF", "S", "T", "U", "W", "YTT"]`
+
+**Type**: `Vec<CheckCodePrefix>`
+
+**Example usage**:
+
+```toml
+[tool.ruff]
+# Only allow autofix behavior for `E` and `F` checks.
+fixable = ["E", "F"]
+```
+
+---
+
+#### [`unfixable`](#unfixable)
+
+A list of check code prefixes to consider un-autofix-able.
+
+**Default value**: `[]`
+
+**Type**: `Vec<CheckCodePrefix>`
+
+**Example usage**:
+
+```toml
+[tool.ruff]
+# Disable autofix for unused imports (`F401`).
+unfixable = ["F401"]
+```
+
+---
+
+#### [`line_length`](#line_length)
+
+The line length to use when enforcing long-lines violations (like E501).
+
+**Default value**: `88`
+
+**Type**: `usize`
+
+**Example usage**:
+
+```toml
+[tool.ruff]
+# Allow lines to be as long as 120 characters.
+line-length = 120
+```
+
+---
+
+#### [`per_file_ignores`](#per_file_ignores)
+
+A list of mappings from file pattern to check code prefixes to exclude, when considering any
+matching files.
+
+**Default value**: `{}`
+
+**Type**: `HashMap<String, Vec<CheckCodePrefix>>`
+
+**Example usage**:
+
+```toml
+[tool.ruff]
+# Ignore `E402` (import violations) in all `__init__.py` files, and in `path/to/file.py`.
+[tool.ruff.per-file-ignores]
+"__init__.py" = ["E402"]
+"path/to/file.py" = ["E402"]
+```
+
+---
+
+#### [`show_source`](#show_source)
+
+Whether to show source code snippets when reporting lint error violations (overridden by the
+`--show-source` command-line flag).
+
+**Default value**: `false`
+
+**Type**: `bool`
+
+**Example usage**:
+
+```toml
+[tool.ruff]
+# By default, always show source code snippets.
+show_source = true
+```
+
+---
+
+#### [`src`](#src)
+
+The source code paths to consider, e.g., when resolving first- vs. third-party imports.
+
+**Default value**: `["."]`
+
+**Type**: `Vec<PathBuf>`
+
+**Example usage**:
+
+```toml
+[tool.ruff]
+# Allow imports relative to the "src" and "test" directories.
+src = ["src", "test"]
+```
+
+---
+
+#### [`target_version`](#target_version)
+
+The Python version to target, e.g., when considering automatic code upgrades, like rewriting type
+annotations. Note that the target version will _not_ be inferred from the _current_ Python version,
+and instead must be specified explicitly (as seen below).
+
+**Default value**: `"py310"`
+
+**Type**: `PythonVersion`
+
+**Example usage**:
+
+```toml
+[tool.ruff]
+# Always generate Python 3.7-compatible code.
+target-version = "py37"
+```
+
+### `flake8-annotations`
+
+#### [`mypy_init_return`](#mypy_init_return)
+
+Whether to allow the omission of a return type hint for `__init__` if at least one argument is
+annotated.
+
+**Default value**: `false`
+
+**Type**: `bool`
+
+**Example usage**:
+
+```toml
+[tool.ruff.flake8-annotations]
+mypy_init_return = true
+```
+
+---
+
+#### [`suppress_dummy_args`](#suppress_dummy_args)
+
+Whether to suppress `ANN000`-level errors for arguments matching the "dummy" variable regex (like
+`_`).
+
+**Default value**: `false`
+
+**Type**: `bool`
+
+**Example usage**:
+
+```toml
+[tool.ruff.flake8-annotations]
+suppress_dummy_args = true
+```
+
+---
+
+#### [`suppress_none_returning`](#suppress_none_returning)
+
+Whether to suppress `ANN200`-level errors for functions that meet either of the following criteria:
+
+- Contain no `return` statement.
+- Explicit `return` statement(s) all return `None` (explicitly or implicitly).
+
+**Default value**: `false`
+
+**Type**: `bool`
+
+**Example usage**:
+
+```toml
+[tool.ruff.flake8-annotations]
+suppress_none_returning = true
+```
+
+---
+
+#### [`allow_star_arg_any`](#allow_star_arg_any)
+
+Whether to suppress `ANN401` for dynamically typed `*args` and `**kwargs` arguments.
+
+**Default value**: `false`
+
+**Type**: `bool`
+
+**Example usage**:
+
+```toml
+[tool.ruff.flake8-annotations]
+allow_star_arg_any = true
+```
+
+### `flake8-bugbear`
+
+#### [`extend_immutable_calls`](#extend_immutable_calls)
+
+Additional callable functions to consider "immutable" when evaluating, e.g., no-mutable-default-argument
+checks (`B006`).
+
+**Default value**: `[]`
+
+**Type**: `Vec<String>`
+
+**Example usage**:
+
+```toml
+[tool.ruff.flake8-bugbear]
+# Allow default arguments like, e.g., `data: List[str] = fastapi.Query(None)`.
+extend-immutable-calls = ["fastapi.Depends", "fastapi.Query"]
+```
+
+### `flake8-quotes`
+
+#### [`inline_quotes`](#inline_quotes)
+
+Quote style to prefer for inline strings (either "single" (`'`) or "double" (`"`)).
+
+**Default value**: `"double"`
+
+**Type**: `Quote`
+
+**Example usage**:
+
+```toml
+[tool.ruff.flake8-quotes]
+inline-quotes = "single"
+```
+
+---
+
+#### [`multiline_quotes`](#multiline_quotes)
+
+Quote style to prefer for multiline strings (either "single" (`'`) or "double" (`"`)).
+
+**Default value**: `"double"`
+
+**Type**: `Quote`
+
+**Example usage**:
+
+```toml
+[tool.ruff.flake8-quotes]
+multiline-quotes = "single"
+```
+
+---
+
+#### [`docstring_quotes`](#docstring_quotes)
+
+Quote style to prefer for docstrings (either "single" (`'`) or "double" (`"`)).
+
+**Default value**: `"double"`
+
+**Type**: `Quote`
+
+**Example usage**:
+
+```toml
+[tool.ruff.flake8-quotes]
+docstring-quotes = "single"
+```
+
+---
+
+#### [`avoid_escape`](#avoid_escape)
+
+Whether to avoid using single quotes if a string contains single quotes, or vice-versa with
+double quotes, as per [PEP8](https://peps.python.org/pep-0008/#string-quotes). This minimizes the
+need to escape quotation marks within strings.
+
+**Default value**: `true`
+
+**Type**: `bool`
+
+**Example usage**:
+
+```toml
+[tool.ruff.flake8-quotes]
+# Don't bother trying to avoid escapes.
+avoid-escape = false
+```
+
+### `flake8-tidy-imports`
+
+#### [`ban_relative_imports`](#ban_relative_imports)
+
+Whether to ban all relative imports (`"all"`), or only those imports that extend into the parent
+module and beyond (`"parents"`).
+
+**Default value**: `"parents"`
+
+**Type**: `Strictness`
+
+**Example usage**:
+
+```toml
+[tool.ruff.flake8-tidy-imports]
+# Disallow all relative imports.
+ban-relative-imports = "all"
+```
+
+### `isort`
+
+#### [`known_first_party`](known_first_party)
+
+A list of modules to consider first-party, regardless of whether they can be identified as such
+via introspection of the local filesystem.
+
+**Default value**: `[]`
+
+**Type**: `Vec<String>`
+
+**Example usage**:
+
+```toml
+[tool.ruff.isort]
+known-first-party = ["src"]
+```
+
+---
+
+#### [`known_third_party`](known_third_party)
+
+A list of modules to consider third-party, regardless of whether they can be identified as such
+via introspection of the local filesystem.
+
+**Default value**: `[]`
+
+**Type**: `Vec<String>`
+
+**Example usage**:
+
+```toml
+[tool.ruff.isort]
+known-third-party = ["fastapi"]
+```
+
+---
+
+#### [`extra_standard_library`](extra_standard_library)
+
+A list of modules to consider standard-library, in addition to those known to Ruff in advance.
+
+**Default value**: `[]`
+
+**Type**: `Vec<String>`
+
+**Example usage**:
+
+```toml
+[tool.ruff.isort]
+extra-standard-library = ["path"]
+```
+
+### `mccabe`
+
+#### [`max_complexity`](#max_complexity)
+
+The maximum McCabe complexity to allow before triggering `C901` errors.
+
+**Default value**: `10`
+
+**Type**: `usize`
+
+**Example usage**:
+
+```toml
+[tool.ruff.flake8-tidy-imports]
+# Flag errors (`C901`) whenever the complexity level exceeds 5.
+max-complexity = 5
+```
+
+### `pep8-naming`
+
+#### [`ignore_names`](#ignore_names)
+
+A list of names to ignore when considering `pep8-naming` violations.
+
+**Default value**: `["setUp", "tearDown", "setUpClass", "tearDownClass", "setUpModule", "tearDownModule", "asyncSetUp", "asyncTearDown", "setUpTestData", "failureException", "longMessage", "maxDiff"]`
+
+**Type**: `Vec<String>`
+
+**Example usage**:
+
+```toml
+[tool.ruff.pep8-naming]
+ignore-names = ["callMethod"]
+```
+
+---
+
+#### [`classmethod_decorators`](#classmethod_decorators)
+
+A list of decorators that, when applied to a method, indicate that the method should be treated as
+a class method. For example, Ruff will expect that any method decorated by a decorator in this list
+takes a `cls` argument as its first argument.
+
+**Default value**: `["classmethod"]`
+
+**Type**: `Vec<String>`
+
+**Example usage**:
+
+```toml
+[tool.ruff.pep8-naming]
+# Allow Pydantic's `@validator` decorator to trigger class method treatment.
+classmethod-decorators = ["classmethod", "pydantic.validator"]
+```
+
+---
+
+#### [`staticmethod_decorators`](#staticmethod_decorators)
+
+A list of decorators that, when applied to a method, indicate that the method should be treated as
+a static method. For example, Ruff will expect that any method decorated by a decorator in this list
+has no `self` or `cls` argument.
+
+**Default value**: `["staticmethod"]`
+
+**Type**: `Vec<String>`
+
+**Example usage**:
+
+```toml
+[tool.ruff.pep8-naming]
+# Allow a shorthand alias, `@stcmthd`, to trigger static method treatment.
+staticmethod-decorators = ["staticmethod", "stcmthd"]
+```
+
 ## License
 
 MIT

flake8_to_ruff/Cargo.lock

@@ -771,7 +771,7 @@ checksum = "0ce7134b9999ecaf8bcd65542e436736ef32ddca1b3e06094cb6ec5755203b80"
 
 [[package]]
 name = "flake8_to_ruff"
-version = "0.0.141"
+version = "0.0.144"
 dependencies = [
  "anyhow",
  "clap",
@@ -1975,7 +1975,7 @@ dependencies = [
 
 [[package]]
 name = "ruff"
-version = "0.0.141"
+version = "0.0.144"
 dependencies = [
  "anyhow",
  "bincode",

flake8_to_ruff/Cargo.toml

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

resources/test/fixtures/D.py

@@ -3,6 +3,7 @@ from functools import wraps
 import os
 from .expected import Expectation
 from typing import overload
+from typing_extensions import override
 
 
 expectation = Expectation()
@@ -42,9 +43,13 @@ class class_:
            "D418: Function/ Method decorated with @overload"
            " shouldn't contain a docstring")
 
+    @override
+    def overridden_method(a):
+        return str(a)
+
     @property
     def foo(self):
-        """The foo of the thing, which isn't in imperitive mood."""
+        """The foo of the thing, which isn't in imperative mood."""
         return "hello"
 
     @expect('D102: Missing docstring in public method')

resources/test/fixtures/E501.py

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

resources/test/fixtures/F502.py

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

resources/test/fixtures/F503.py

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

resources/test/fixtures/F504.py

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

resources/test/fixtures/F50x.py

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

resources/test/fixtures/FBT.py

@@ -38,5 +38,20 @@ def function(
 def used(do):
     return do
 
+
 used("a", True)
 used(do=True)
+
+
+# Avoid FBT003 for explicitly allowed methods.
+"""
+FBT003 Boolean positional value on dict
+"""
+a = {"a": "b"}
+a.get("hello", False)
+{}.get("hello", False)
+{}.setdefault("hello", True)
+{}.pop("hello", False)
+{}.pop(True, False)
+dict.fromkeys(("world",), True)
+{}.deploy(True, False)

resources/test/fixtures/canonical_google_examples.py

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

resources/test/fixtures/canonical_numpy_examples.py

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

ruff_dev/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ruff_dev"
-version = "0.0.141"
+version = "0.0.144"
 edition = "2021"
 
 [dependencies]

src/check_ast.rs

@@ -33,6 +33,7 @@ use crate::python::typing::SubscriptKind;
 use crate::settings::types::PythonVersion;
 use crate::settings::Settings;
 use crate::source_code_locator::SourceCodeLocator;
+use crate::vendored::cformat::{CFormatError, CFormatErrorType};
 use crate::visibility::{module_visibility, transition_scope, Modifier, Visibility, VisibleScope};
 use crate::{
     docstrings, flake8_2020, flake8_annotations, flake8_bandit, flake8_blind_except,
@@ -713,12 +714,7 @@ where
                         self.from_imports
                             .entry(module)
                             .or_insert_with(FxHashSet::default)
-                            .extend(
-                                names
-                                    .iter()
-                                    .filter(|alias| alias.node.asname.is_none())
-                                    .map(|alias| alias.node.name.as_str()),
-                            );
+                            .extend(names.iter().map(|alias| alias.node.name.as_str()));
                     }
                     for alias in names {
                         if let Some(asname) = &alias.node.asname {
@@ -1642,7 +1638,7 @@ where
                 // flake8-boolean-trap
                 if self.settings.enabled.contains(&CheckCode::FBT003) {
                     flake8_boolean_trap::plugins::check_boolean_positional_value_in_function_call(
-                        self, args,
+                        self, args, func,
                     );
                 }
                 if let ExprKind::Name { id, ctx } = &func.node {
@@ -1721,6 +1717,116 @@ where
                     pyflakes::plugins::invalid_print_syntax(self, left);
                 }
             }
+            ExprKind::BinOp {
+                left,
+                op: Operator::Mod,
+                right,
+            } => {
+                if let ExprKind::Constant {
+                    value: Constant::Str(value),
+                    ..
+                } = &left.node
+                {
+                    if self.settings.enabled.contains(&CheckCode::F501)
+                        || self.settings.enabled.contains(&CheckCode::F502)
+                        || self.settings.enabled.contains(&CheckCode::F503)
+                        || self.settings.enabled.contains(&CheckCode::F504)
+                        || self.settings.enabled.contains(&CheckCode::F505)
+                        || self.settings.enabled.contains(&CheckCode::F506)
+                        || self.settings.enabled.contains(&CheckCode::F507)
+                        || self.settings.enabled.contains(&CheckCode::F508)
+                        || self.settings.enabled.contains(&CheckCode::F509)
+                    {
+                        let location = Range::from_located(expr);
+                        match pyflakes::cformat::CFormatSummary::try_from(value.as_ref()) {
+                            Err(CFormatError {
+                                typ: CFormatErrorType::UnsupportedFormatChar(c),
+                                ..
+                            }) => {
+                                if self.settings.enabled.contains(&CheckCode::F509) {
+                                    self.add_check(Check::new(
+                                        CheckKind::PercentFormatUnsupportedFormatCharacter(c),
+                                        location,
+                                    ));
+                                }
+                            }
+                            Err(e) => {
+                                if self.settings.enabled.contains(&CheckCode::F501) {
+                                    self.add_check(Check::new(
+                                        CheckKind::PercentFormatInvalidFormat(e.to_string()),
+                                        location,
+                                    ));
+                                }
+                            }
+                            Ok(summary) => {
+                                if self.settings.enabled.contains(&CheckCode::F502) {
+                                    if let Some(check) =
+                                        pyflakes::checks::percent_format_expected_mapping(
+                                            &summary, right, location,
+                                        )
+                                    {
+                                        self.add_check(check);
+                                    }
+                                }
+                                if self.settings.enabled.contains(&CheckCode::F503) {
+                                    if let Some(check) =
+                                        pyflakes::checks::percent_format_expected_sequence(
+                                            &summary, right, location,
+                                        )
+                                    {
+                                        self.add_check(check);
+                                    }
+                                }
+                                if self.settings.enabled.contains(&CheckCode::F504) {
+                                    if let Some(check) =
+                                        pyflakes::checks::percent_format_extra_named_arguments(
+                                            &summary, right, location,
+                                        )
+                                    {
+                                        self.add_check(check);
+                                    }
+                                }
+                                if self.settings.enabled.contains(&CheckCode::F505) {
+                                    if let Some(check) =
+                                        pyflakes::checks::percent_format_missing_arguments(
+                                            &summary, right, location,
+                                        )
+                                    {
+                                        self.add_check(check);
+                                    }
+                                }
+                                if self.settings.enabled.contains(&CheckCode::F506) {
+                                    if let Some(check) =
+                                        pyflakes::checks::percent_format_mixed_positional_and_named(
+                                            &summary, location,
+                                        )
+                                    {
+                                        self.add_check(check);
+                                    }
+                                }
+                                if self.settings.enabled.contains(&CheckCode::F507) {
+                                    if let Some(check) =
+                                        pyflakes::checks::percent_format_positional_count_mismatch(
+                                            &summary, right, location,
+                                        )
+                                    {
+                                        self.add_check(check);
+                                    }
+                                }
+                                if self.settings.enabled.contains(&CheckCode::F508) {
+                                    if let Some(check) =
+                                        pyflakes::checks::percent_format_star_requires_sequence(
+                                            &summary, right, location,
+                                        )
+                                    {
+                                        self.add_check(check);
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
             ExprKind::UnaryOp { op, operand } => {
                 let check_not_in = self.settings.enabled.contains(&CheckCode::E713);
                 let check_not_is = self.settings.enabled.contains(&CheckCode::E714);

src/check_lines.rs

@@ -16,13 +16,16 @@ use crate::settings::Settings;
 static CODING_COMMENT_REGEX: Lazy<Regex> =
     Lazy::new(|| Regex::new(r"^[ \t\f]*#.*?coding[:=][ \t]*utf-?8").expect("Invalid regex"));
 
+static URL_REGEX: Lazy<Regex> = Lazy::new(|| Regex::new(r"^https?://\S+$").expect("Invalid regex"));
+
 /// Whether the given line is too long and should be reported.
 fn should_enforce_line_length(line: &str, length: usize, limit: usize) -> bool {
     if length > limit {
         let mut chunks = line.split_whitespace();
         if let (Some(first), Some(_)) = (chunks.next(), chunks.next()) {
-            // Do not enforce the line length for commented lines with a single word
-            !(first == "#" && chunks.next().is_none())
+            // Do not enforce the line length for commented lines that end with a URL
+            // or contain only a single word.
+            !(first == "#" && chunks.last().map_or(true, |c| URL_REGEX.is_match(c)))
         } else {
             // Single word / no printable chars - no way to make the line shorter
             false

src/checks.rs

@@ -53,6 +53,15 @@ pub enum CheckCode {
     F405,
     F406,
     F407,
+    F501,
+    F502,
+    F503,
+    F504,
+    F505,
+    F506,
+    F507,
+    F508,
+    F509,
     F521,
     F522,
     F523,
@@ -415,6 +424,15 @@ pub enum CheckKind {
     LateFutureImport,
     MultiValueRepeatedKeyLiteral,
     MultiValueRepeatedKeyVariable(String),
+    PercentFormatExpectedMapping,
+    PercentFormatExpectedSequence,
+    PercentFormatExtraNamedArguments(Vec<String>),
+    PercentFormatInvalidFormat(String),
+    PercentFormatMissingArgument(Vec<String>),
+    PercentFormatMixedPositionalAndNamed,
+    PercentFormatPositionalCountMismatch(usize, usize),
+    PercentFormatStarRequiresSequence,
+    PercentFormatUnsupportedFormatCharacter(char),
     RaiseNotImplemented,
     ReturnOutsideFunction,
     StringDotFormatExtraNamedArguments(Vec<String>),
@@ -668,6 +686,15 @@ impl CheckCode {
             }
             CheckCode::F406 => CheckKind::ImportStarNotPermitted("...".to_string()),
             CheckCode::F407 => CheckKind::FutureFeatureNotDefined("...".to_string()),
+            CheckCode::F501 => CheckKind::PercentFormatInvalidFormat("...".to_string()),
+            CheckCode::F502 => CheckKind::PercentFormatExpectedMapping,
+            CheckCode::F503 => CheckKind::PercentFormatExpectedSequence,
+            CheckCode::F504 => CheckKind::PercentFormatExtraNamedArguments(vec!["...".to_string()]),
+            CheckCode::F505 => CheckKind::PercentFormatMissingArgument(vec!["...".to_string()]),
+            CheckCode::F506 => CheckKind::PercentFormatMixedPositionalAndNamed,
+            CheckCode::F507 => CheckKind::PercentFormatPositionalCountMismatch(4, 2),
+            CheckCode::F508 => CheckKind::PercentFormatStarRequiresSequence,
+            CheckCode::F509 => CheckKind::PercentFormatUnsupportedFormatCharacter('c'),
             CheckCode::F521 => CheckKind::StringDotFormatInvalidFormat("...".to_string()),
             CheckCode::F522 => {
                 CheckKind::StringDotFormatExtraNamedArguments(vec!["...".to_string()])
@@ -946,6 +973,15 @@ impl CheckCode {
             CheckCode::F405 => CheckCategory::Pyflakes,
             CheckCode::F406 => CheckCategory::Pyflakes,
             CheckCode::F407 => CheckCategory::Pyflakes,
+            CheckCode::F501 => CheckCategory::Pyflakes,
+            CheckCode::F502 => CheckCategory::Pyflakes,
+            CheckCode::F503 => CheckCategory::Pyflakes,
+            CheckCode::F504 => CheckCategory::Pyflakes,
+            CheckCode::F505 => CheckCategory::Pyflakes,
+            CheckCode::F506 => CheckCategory::Pyflakes,
+            CheckCode::F507 => CheckCategory::Pyflakes,
+            CheckCode::F508 => CheckCategory::Pyflakes,
+            CheckCode::F509 => CheckCategory::Pyflakes,
             CheckCode::F521 => CheckCategory::Pyflakes,
             CheckCode::F522 => CheckCategory::Pyflakes,
             CheckCode::F523 => CheckCategory::Pyflakes,
@@ -1175,6 +1211,15 @@ impl CheckKind {
             CheckKind::NoneComparison(_) => &CheckCode::E711,
             CheckKind::NotInTest => &CheckCode::E713,
             CheckKind::NotIsTest => &CheckCode::E714,
+            CheckKind::PercentFormatExpectedMapping => &CheckCode::F502,
+            CheckKind::PercentFormatExpectedSequence => &CheckCode::F503,
+            CheckKind::PercentFormatExtraNamedArguments(_) => &CheckCode::F504,
+            CheckKind::PercentFormatInvalidFormat(_) => &CheckCode::F501,
+            CheckKind::PercentFormatMissingArgument(_) => &CheckCode::F505,
+            CheckKind::PercentFormatMixedPositionalAndNamed => &CheckCode::F506,
+            CheckKind::PercentFormatPositionalCountMismatch(..) => &CheckCode::F507,
+            CheckKind::PercentFormatStarRequiresSequence => &CheckCode::F508,
+            CheckKind::PercentFormatUnsupportedFormatCharacter(_) => &CheckCode::F509,
             CheckKind::RaiseNotImplemented => &CheckCode::F901,
             CheckKind::ReturnOutsideFunction => &CheckCode::F706,
             CheckKind::StringDotFormatExtraNamedArguments(_) => &CheckCode::F522,
@@ -1465,6 +1510,35 @@ impl CheckKind {
             },
             CheckKind::NotInTest => "Test for membership should be `not in`".to_string(),
             CheckKind::NotIsTest => "Test for object identity should be `is not`".to_string(),
+            CheckKind::PercentFormatInvalidFormat(message) => {
+                format!("'...' % ... has invalid format string: {message}")
+            }
+            CheckKind::PercentFormatUnsupportedFormatCharacter(char) => {
+                format!("'...' % ... has unsupported format character '{char}'")
+            }
+            CheckKind::PercentFormatExpectedMapping => {
+                "'...' % ... expected mapping but got sequence".to_string()
+            }
+            CheckKind::PercentFormatExpectedSequence => {
+                "'...' % ... expected sequence but got mapping".to_string()
+            }
+            CheckKind::PercentFormatExtraNamedArguments(missing) => {
+                let message = missing.join(", ");
+                format!("'...' % ... has unused named argument(s): {message}")
+            }
+            CheckKind::PercentFormatMissingArgument(missing) => {
+                let message = missing.join(", ");
+                format!("'...' % ... is missing argument(s) for placeholder(s): {message}")
+            }
+            CheckKind::PercentFormatMixedPositionalAndNamed => {
+                "'...' % ... has mixed positional and named placeholders".to_string()
+            }
+            CheckKind::PercentFormatPositionalCountMismatch(wanted, got) => {
+                format!("'...' % ... has {wanted} placeholder(s) but {got} substitution(s)")
+            }
+            CheckKind::PercentFormatStarRequiresSequence => {
+                "'...' % ... `*` specifier requires sequence".to_string()
+            }
             CheckKind::RaiseNotImplemented => {
                 "`raise NotImplemented` should be `raise NotImplementedError`".to_string()
             }

src/checks_gen.rs

@@ -861,6 +861,15 @@ impl CheckCodePrefix {
                 CheckCode::F405,
                 CheckCode::F406,
                 CheckCode::F407,
+                CheckCode::F501,
+                CheckCode::F502,
+                CheckCode::F503,
+                CheckCode::F504,
+                CheckCode::F505,
+                CheckCode::F506,
+                CheckCode::F507,
+                CheckCode::F508,
+                CheckCode::F509,
                 CheckCode::F521,
                 CheckCode::F522,
                 CheckCode::F523,

src/cli.rs

@@ -15,7 +15,7 @@ use crate::settings::types::{FilePattern, PatternPrefixPair, PerFileIgnore, Pyth
 #[command(version)]
 #[allow(clippy::struct_excessive_bools)]
 pub struct Cli {
-    #[arg(required = true)]
+    #[arg(required_unless_present_any = ["explain", "generate_shell_completion"])]
     pub files: Vec<PathBuf>,
     /// Path to the `pyproject.toml` file to use for configuration.
     #[arg(long)]
@@ -114,6 +114,9 @@ pub struct Cli {
     /// Explain a rule.
     #[arg(long)]
     pub explain: Option<CheckCode>,
+    /// Generate shell completion
+    #[arg(long, hide = true, value_name = "SHELL")]
+    pub generate_shell_completion: Option<clap_complete_command::Shell>,
 }
 
 impl Cli {

src/flake8_boolean_trap/plugins.rs

@@ -5,6 +5,19 @@ use crate::ast::types::Range;
 use crate::check_ast::Checker;
 use crate::checks::{Check, CheckKind};
 
+const FUNC_NAME_ALLOWLIST: &[&str] = &["get", "setdefault", "pop", "fromkeys"];
+
+/// Returns `true` if an argument is allowed to use a boolean trap. To return
+/// `true`, the function name must be explicitly allowed, and the argument must
+/// be either the first or second argument in the call.
+fn allow_boolean_trap(func: &Expr) -> bool {
+    if let ExprKind::Attribute { attr, .. } = &func.node {
+        FUNC_NAME_ALLOWLIST.contains(&attr.as_ref())
+    } else {
+        false
+    }
+}
+
 fn is_boolean_arg(arg: &Expr) -> bool {
     matches!(
         &arg.node,
@@ -60,8 +73,15 @@ pub fn check_boolean_default_value_in_function_definition(
     }
 }
 
-pub fn check_boolean_positional_value_in_function_call(checker: &mut Checker, args: &[Expr]) {
-    for arg in args {
+pub fn check_boolean_positional_value_in_function_call(
+    checker: &mut Checker,
+    args: &[Expr],
+    func: &Expr,
+) {
+    for (index, arg) in args.iter().enumerate() {
+        if index < 2 && allow_boolean_trap(func) {
+            continue;
+        }
         add_if_boolean(
             checker,
             arg,

src/flake8_comprehensions/fixes.rs

@@ -39,9 +39,7 @@ pub fn fix_unnecessary_generator_list(
     let call = match_call(body)?;
     let arg = match_arg(call)?;
 
-    let generator_exp = if let Expression::GeneratorExp(generator_exp) = &arg.value {
-        generator_exp
-    } else {
+    let Expression::GeneratorExp(generator_exp) = &arg.value else {
         return Err(anyhow::anyhow!(
             "Expected node to be: Expression::GeneratorExp"
         ));
@@ -82,9 +80,7 @@ pub fn fix_unnecessary_generator_set(
     let call = match_call(body)?;
     let arg = match_arg(call)?;
 
-    let generator_exp = if let Expression::GeneratorExp(generator_exp) = &arg.value {
-        generator_exp
-    } else {
+    let Expression::GeneratorExp(generator_exp) = &arg.value else {
         return Err(anyhow::anyhow!(
             "Expected node to be: Expression::GeneratorExp"
         ));
@@ -126,28 +122,20 @@ pub fn fix_unnecessary_generator_dict(
     let arg = match_arg(call)?;
 
     // Extract the (k, v) from `(k, v) for ...`.
-    let generator_exp = if let Expression::GeneratorExp(generator_exp) = &arg.value {
-        generator_exp
-    } else {
+    let Expression::GeneratorExp(generator_exp) = &arg.value else {
         return Err(anyhow::anyhow!(
             "Expected node to be: Expression::GeneratorExp"
         ));
     };
-    let tuple = if let Expression::Tuple(tuple) = &generator_exp.elt.as_ref() {
-        tuple
-    } else {
+    let Expression::Tuple(tuple) = &generator_exp.elt.as_ref() else {
         return Err(anyhow::anyhow!("Expected node to be: Expression::Tuple"));
     };
-    let key = if let Some(Element::Simple { value, .. }) = &tuple.elements.get(0) {
-        value
-    } else {
+    let Some(Element::Simple { value: key, .. }) = &tuple.elements.get(0) else {
         return Err(anyhow::anyhow!(
             "Expected tuple to contain a key as the first element"
         ));
     };
-    let value = if let Some(Element::Simple { value, .. }) = &tuple.elements.get(1) {
-        value
-    } else {
+    let Some(Element::Simple { value, .. }) = &tuple.elements.get(1) else {
         return Err(anyhow::anyhow!(
             "Expected tuple to contain a key as the second element"
         ));
@@ -192,9 +180,7 @@ pub fn fix_unnecessary_list_comprehension_set(
     let call = match_call(body)?;
     let arg = match_arg(call)?;
 
-    let list_comp = if let Expression::ListComp(list_comp) = &arg.value {
-        list_comp
-    } else {
+    let Expression::ListComp(list_comp) = &arg.value else {
         return Err(anyhow::anyhow!("Expected node to be: Expression::ListComp"));
     };
 
@@ -233,25 +219,18 @@ pub fn fix_unnecessary_list_comprehension_dict(
     let call = match_call(body)?;
     let arg = match_arg(call)?;
 
-    let list_comp = if let Expression::ListComp(list_comp) = &arg.value {
-        list_comp
-    } else {
+    let Expression::ListComp(list_comp) = &arg.value else {
         return Err(anyhow::anyhow!("Expected node to be: Expression::ListComp"));
     };
 
-    let tuple = if let Expression::Tuple(tuple) = &*list_comp.elt {
-        tuple
-    } else {
+    let Expression::Tuple(tuple) = &*list_comp.elt else {
         return Err(anyhow::anyhow!("Expected node to be: Expression::Tuple"));
     };
 
-    let (key, comma, value) = match &tuple.elements[..] {
-        [Element::Simple {
+    let [Element::Simple {
             value: key,
             comma: Some(comma),
-        }, Element::Simple { value, .. }] => (key, comma, value),
-        _ => return Err(anyhow::anyhow!("Expected tuple with two elements")),
-    };
+        }, Element::Simple { value, .. }] = &tuple.elements[..] else { return Err(anyhow::anyhow!("Expected tuple with two elements")) };
 
     body.value = Expression::DictComp(Box::new(DictComp {
         key: Box::new(key.clone()),
@@ -409,9 +388,7 @@ pub fn fix_unnecessary_collection_call(
     let mut tree = match_module(&module_text)?;
     let mut body = match_expr(&mut tree)?;
     let call = match_call(body)?;
-    let name = if let Expression::Name(name) = &call.func.as_ref() {
-        name
-    } else {
+    let Expression::Name(name) = &call.func.as_ref() else {
         return Err(anyhow::anyhow!("Expected node to be: Expression::Name"));
     };
 

src/linter.rs

@@ -518,6 +518,19 @@ mod tests {
     #[test_case(CheckCode::F405, Path::new("F405.py"); "F405")]
     #[test_case(CheckCode::F406, Path::new("F406.py"); "F406")]
     #[test_case(CheckCode::F407, Path::new("F407.py"); "F407")]
+    #[test_case(CheckCode::F501, Path::new("F50x.py"); "F501")]
+    #[test_case(CheckCode::F502, Path::new("F50x.py"); "F502_0")]
+    #[test_case(CheckCode::F502, Path::new("F502.py"); "F502_1")]
+    #[test_case(CheckCode::F503, Path::new("F50x.py"); "F503_0")]
+    #[test_case(CheckCode::F503, Path::new("F503.py"); "F503_1")]
+    #[test_case(CheckCode::F504, Path::new("F50x.py"); "F504_0")]
+    #[test_case(CheckCode::F504, Path::new("F504.py"); "F504_1")]
+    #[test_case(CheckCode::F505, Path::new("F50x.py"); "F505_0")]
+    #[test_case(CheckCode::F505, Path::new("F504.py"); "F505_1")]
+    #[test_case(CheckCode::F506, Path::new("F50x.py"); "F506")]
+    #[test_case(CheckCode::F507, Path::new("F50x.py"); "F507")]
+    #[test_case(CheckCode::F508, Path::new("F50x.py"); "F508")]
+    #[test_case(CheckCode::F509, Path::new("F50x.py"); "F509")]
     #[test_case(CheckCode::F521, Path::new("F521.py"); "F521")]
     #[test_case(CheckCode::F522, Path::new("F522.py"); "F522")]
     #[test_case(CheckCode::F523, Path::new("F523.py"); "F523")]

src/main.rs

@@ -30,7 +30,7 @@ use ::ruff::settings::{pyproject, Settings};
 use ::ruff::updates;
 use ::ruff::{cache, commands};
 use anyhow::Result;
-use clap::Parser;
+use clap::{CommandFactory, Parser};
 use colored::Colorize;
 use log::{debug, error};
 use notify::{raw_watcher, RecursiveMode, Watcher};
@@ -193,6 +193,16 @@ fn inner_main() -> Result<ExitCode> {
     let log_level = extract_log_level(&cli);
     set_up_logging(&log_level)?;
 
+    if let Some(code) = cli.explain {
+        commands::explain(&code, cli.format)?;
+        return Ok(ExitCode::SUCCESS);
+    }
+
+    if let Some(shell) = cli.generate_shell_completion {
+        shell.generate(&mut Cli::command(), &mut std::io::stdout());
+        return Ok(ExitCode::SUCCESS);
+    }
+
     // Find the project root and pyproject.toml.
     let project_root = pyproject::find_project_root(&cli.files);
     match &project_root {
@@ -256,11 +266,6 @@ fn inner_main() -> Result<ExitCode> {
         configuration.show_source = true;
     }
 
-    if let Some(code) = cli.explain {
-        commands::explain(&code, cli.format)?;
-        return Ok(ExitCode::SUCCESS);
-    }
-
     if cli.show_settings && cli.show_files {
         eprintln!("Error: specify --show-settings or show-files (not both).");
         return Ok(ExitCode::FAILURE);

src/pydocstyle/plugins.rs

@@ -4,7 +4,7 @@ use itertools::Itertools;
 use once_cell::sync::Lazy;
 use regex::Regex;
 use rustc_hash::FxHashSet;
-use rustpython_ast::{Arg, Constant, ExprKind, Location, StmtKind};
+use rustpython_ast::{Constant, ExprKind, Location, StmtKind};
 
 use crate::ast::types::Range;
 use crate::ast::whitespace;
@@ -15,7 +15,7 @@ use crate::docstrings::constants;
 use crate::docstrings::definition::{Definition, DefinitionKind};
 use crate::docstrings::sections::{section_contexts, SectionContext};
 use crate::docstrings::styles::SectionStyle;
-use crate::visibility::{is_init, is_magic, is_overload, is_staticmethod, Visibility};
+use crate::visibility::{is_init, is_magic, is_overload, is_override, is_staticmethod, Visibility};
 
 /// D100, D101, D102, D103, D104, D105, D106, D107
 pub fn not_missing(
@@ -88,7 +88,7 @@ pub fn not_missing(
             }
         }
         DefinitionKind::Method(stmt) => {
-            if is_overload(stmt) {
+            if is_overload(stmt) || is_override(stmt) {
                 true
             } else if is_magic(stmt) {
                 if checker.settings.enabled.contains(&CheckCode::D105) {
@@ -1303,8 +1303,9 @@ fn missing_args(checker: &mut Checker, definition: &Definition, docstrings_args:
             args: arguments, ..
         } = &parent.node
         {
-            // Collect all the arguments into a single vector.
-            let mut all_arguments: Vec<&Arg> = arguments
+            // Look for arguments that weren't included in the docstring.
+            let mut missing_arg_names: BTreeSet<String> = BTreeSet::default();
+            for arg in arguments
                 .args
                 .iter()
                 .chain(arguments.posonlyargs.iter())
@@ -1316,33 +1317,38 @@ fn missing_args(checker: &mut Checker, definition: &Definition, docstrings_args:
                             && !is_staticmethod(parent),
                     ),
                 )
-                .collect();
+            {
+                let arg_name = arg.node.arg.as_str();
+                if !arg_name.starts_with('_') && !docstrings_args.contains(&arg_name) {
+                    missing_arg_names.insert(arg_name.to_string());
+                }
+            }
+
+            // Check specifically for `vararg` and `kwarg`, which can be prefixed with a
+            // single or double star, respectively.
             if let Some(arg) = &arguments.vararg {
-                all_arguments.push(arg);
+                let arg_name = arg.node.arg.as_str();
+                let starred_arg_name = format!("*{arg_name}");
+                if !arg_name.starts_with('_')
+                    && !docstrings_args.contains(&arg_name)
+                    && !docstrings_args.contains(&starred_arg_name.as_str())
+                {
+                    missing_arg_names.insert(starred_arg_name);
+                }
             }
             if let Some(arg) = &arguments.kwarg {
-                all_arguments.push(arg);
-            }
-
-            // Look for arguments that weren't included in the docstring.
-            let mut missing_args: BTreeSet<&str> = BTreeSet::default();
-            for arg in all_arguments {
                 let arg_name = arg.node.arg.as_str();
-                if arg_name.starts_with('_') {
-                    continue;
+                let starred_arg_name = format!("**{arg_name}");
+                if !arg_name.starts_with('_')
+                    && !docstrings_args.contains(&arg_name)
+                    && !docstrings_args.contains(&starred_arg_name.as_str())
+                {
+                    missing_arg_names.insert(starred_arg_name);
                 }
-                if docstrings_args.contains(&arg_name) {
-                    continue;
-                }
-                missing_args.insert(arg_name);
             }
 
-            if !missing_args.is_empty() {
-                let names = missing_args
-                    .into_iter()
-                    .map(String::from)
-                    .sorted()
-                    .collect();
+            if !missing_arg_names.is_empty() {
+                let names = missing_arg_names.into_iter().sorted().collect();
                 checker.add_check(Check::new(
                     CheckKind::DocumentAllArguments(names),
                     Range::from_located(parent),

src/pyflakes/cformat.rs

@@ -0,0 +1,102 @@
+//! Implements helper functions for using vendored/cformat.rs
+use std::convert::TryFrom;
+use std::str::FromStr;
+
+use rustc_hash::FxHashSet;
+
+use crate::vendored::cformat::{
+    CFormatError, CFormatPart, CFormatQuantity, CFormatSpec, CFormatString,
+};
+
+pub(crate) struct CFormatSummary {
+    pub starred: bool,
+    pub num_positional: usize,
+    pub keywords: FxHashSet<String>,
+}
+
+impl TryFrom<&str> for CFormatSummary {
+    type Error = CFormatError;
+
+    fn try_from(literal: &str) -> Result<Self, Self::Error> {
+        let format_string = CFormatString::from_str(literal)?;
+
+        let mut starred = false;
+        let mut num_positional = 0;
+        let mut keywords = FxHashSet::default();
+
+        for format_part in format_string.parts {
+            if let CFormatPart::Spec(CFormatSpec {
+                mapping_key,
+                min_field_width,
+                precision,
+                ..
+            }) = format_part.1
+            {
+                match mapping_key {
+                    Some(k) => {
+                        keywords.insert(k);
+                    }
+                    None => {
+                        num_positional += 1;
+                    }
+                };
+                if min_field_width == Some(CFormatQuantity::FromValuesTuple) {
+                    num_positional += 1;
+                    starred = true;
+                }
+                if precision == Some(CFormatQuantity::FromValuesTuple) {
+                    num_positional += 1;
+                    starred = true;
+                }
+            }
+        }
+
+        Ok(CFormatSummary {
+            starred,
+            num_positional,
+            keywords,
+        })
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_cformat_summary() {
+        let literal = "%(foo)s %s %d %(bar)x";
+
+        let expected_positional = 2;
+        let expected_keywords = ["foo", "bar"].into_iter().map(String::from).collect();
+
+        let format_summary = CFormatSummary::try_from(literal).unwrap();
+        assert!(!format_summary.starred);
+        assert_eq!(format_summary.num_positional, expected_positional);
+        assert_eq!(format_summary.keywords, expected_keywords);
+    }
+
+    #[test]
+    fn test_cformat_summary_starred() {
+        let format_summary1 = CFormatSummary::try_from("%*s %*d").unwrap();
+        assert!(format_summary1.starred);
+        assert_eq!(format_summary1.num_positional, 4);
+
+        let format_summary2 = CFormatSummary::try_from("%s %.*d").unwrap();
+        assert!(format_summary2.starred);
+        assert_eq!(format_summary2.num_positional, 3);
+
+        let format_summary3 = CFormatSummary::try_from("%s %*.*d").unwrap();
+        assert!(format_summary3.starred);
+        assert_eq!(format_summary3.num_positional, 4);
+
+        let format_summary4 = CFormatSummary::try_from("%s %1d").unwrap();
+        assert!(!format_summary4.starred);
+    }
+
+    #[test]
+    fn test_cformat_summary_invalid() {
+        assert!(CFormatSummary::try_from("%").is_err());
+        assert!(CFormatSummary::try_from("%(foo).").is_err());
+    }
+}

src/pyflakes/checks.rs

@@ -9,6 +9,7 @@ use rustpython_parser::ast::{
 
 use crate::ast::types::{BindingKind, FunctionScope, 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 {
@@ -23,6 +24,216 @@ fn has_star_args(args: &[Expr]) -> bool {
         .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;
+    }
+
+    if let ExprKind::Dict { keys, values } = &right.node {
+        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() {
+            None
+        } else {
+            Some(Check::new(
+                CheckKind::PercentFormatExtraNamedArguments(
+                    missing.iter().map(|&s| s.clone()).collect(),
+                ),
+                location,
+            ))
+        }
+    } else {
+        None
+    }
+}
+
+/// 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,
@@ -38,16 +249,17 @@ pub(crate) fn string_dot_format_extra_named_arguments(
         arg.as_ref()
     });
 
-    let missing: Vec<String> = keywords
+    let missing: Vec<&String> = keywords
         .filter(|&k| !summary.keywords.contains(k))
-        .cloned()
         .collect();
 
     if missing.is_empty() {
         None
     } else {
         Some(Check::new(
-            CheckKind::StringDotFormatExtraNamedArguments(missing),
+            CheckKind::StringDotFormatExtraNamedArguments(
+                missing.iter().map(|&s| s.clone()).collect(),
+            ),
             location,
         ))
     }

src/pyflakes/fixes.rs

@@ -22,14 +22,10 @@ pub fn remove_unused_imports(
     let module_text = locator.slice_source_code_range(&Range::from_located(stmt));
     let mut tree = match_module(&module_text)?;
 
-    let body = if let Some(Statement::Simple(body)) = tree.body.first_mut() {
-        body
-    } else {
+    let Some(Statement::Simple(body)) = tree.body.first_mut() else {
         return Err(anyhow::anyhow!("Expected node to be: Statement::Simple"));
     };
-    let body = if let Some(SmallStatement::Import(body)) = body.body.first_mut() {
-        body
-    } else {
+    let Some(SmallStatement::Import(body)) = body.body.first_mut() else {
         return Err(anyhow::anyhow!(
             "Expected node to be: SmallStatement::ImportFrom"
         ));
@@ -80,22 +76,16 @@ pub fn remove_unused_import_froms(
     let module_text = locator.slice_source_code_range(&Range::from_located(stmt));
     let mut tree = match_module(&module_text)?;
 
-    let body = if let Some(Statement::Simple(body)) = tree.body.first_mut() {
-        body
-    } else {
+    let Some(Statement::Simple(body)) = tree.body.first_mut() else {
         return Err(anyhow::anyhow!("Expected node to be: Statement::Simple"));
     };
-    let body = if let Some(SmallStatement::ImportFrom(body)) = body.body.first_mut() {
-        body
-    } else {
+    let Some(SmallStatement::ImportFrom(body)) = body.body.first_mut() else {
         return Err(anyhow::anyhow!(
             "Expected node to be: SmallStatement::ImportFrom"
         ));
     };
 
-    let aliases = if let ImportNames::Aliases(aliases) = &mut body.names {
-        aliases
-    } else {
+    let ImportNames::Aliases(aliases) = &mut body.names else {
         return Err(anyhow::anyhow!("Expected node to be: Aliases"));
     };
 

src/pyflakes/mod.rs

@@ -1,3 +1,4 @@
+pub mod cformat;
 pub mod checks;
 pub mod fixes;
 pub mod format;

src/pyupgrade/fixes.rs

@@ -111,10 +111,7 @@ pub fn remove_super_arguments(locator: &SourceCodeLocator, expr: &Expr) -> Optio
     let range = Range::from_located(expr);
     let contents = locator.slice_source_code_range(&range);
 
-    let mut tree = match libcst_native::parse_module(&contents, None) {
-        Ok(m) => m,
-        Err(_) => return None,
-    };
+    let mut tree = libcst_native::parse_module(&contents, None).ok()?;
 
     if let Some(Statement::Simple(body)) = tree.body.first_mut() {
         if let Some(SmallStatement::Expr(body)) = body.body.first_mut() {
@@ -150,22 +147,16 @@ pub fn remove_unnecessary_future_import(
     let module_text = locator.slice_source_code_range(&Range::from_located(stmt));
     let mut tree = match_module(&module_text)?;
 
-    let body = if let Some(Statement::Simple(body)) = tree.body.first_mut() {
-        body
-    } else {
+    let Some(Statement::Simple(body)) = tree.body.first_mut() else {
         return Err(anyhow::anyhow!("Expected node to be: Statement::Simple"));
     };
-    let body = if let Some(SmallStatement::ImportFrom(body)) = body.body.first_mut() {
-        body
-    } else {
+    let Some(SmallStatement::ImportFrom(body)) = body.body.first_mut() else {
         return Err(anyhow::anyhow!(
             "Expected node to be: SmallStatement::ImportFrom"
         ));
     };
 
-    let aliases = if let ImportNames::Aliases(aliases) = &mut body.names {
-        aliases
-    } else {
+    let ImportNames::Aliases(aliases) = &mut body.names else {
         return Err(anyhow::anyhow!("Expected node to be: Aliases"));
     };
 

src/snapshots/ruff__linter__tests__D101_D.py.snap

@@ -4,10 +4,10 @@ expression: checks
 ---
 - kind: PublicClass
   location:
-    row: 14
+    row: 15
     column: 0
   end_location:
-    row: 67
+    row: 72
     column: 0
   fix: ~
 

src/snapshots/ruff__linter__tests__D102_D.py.snap

@@ -4,26 +4,26 @@ expression: checks
 ---
 - kind: PublicMethod
   location:
-    row: 22
+    row: 23
     column: 4
   end_location:
-    row: 25
+    row: 26
     column: 4
   fix: ~
 - kind: PublicMethod
   location:
-    row: 51
+    row: 56
     column: 4
   end_location:
-    row: 54
+    row: 59
     column: 4
   fix: ~
 - kind: PublicMethod
   location:
-    row: 63
+    row: 68
     column: 4
   end_location:
-    row: 67
+    row: 72
     column: 0
   fix: ~
 

src/snapshots/ruff__linter__tests__D103_D.py.snap

@@ -4,10 +4,10 @@ expression: checks
 ---
 - kind: PublicFunction
   location:
-    row: 395
+    row: 400
     column: 0
   end_location:
-    row: 396
+    row: 401
     column: 0
   fix: ~
 

src/snapshots/ruff__linter__tests__D105_D.py.snap

@@ -4,10 +4,10 @@ expression: checks
 ---
 - kind: MagicMethod
   location:
-    row: 59
+    row: 64
     column: 4
   end_location:
-    row: 62
+    row: 67
     column: 4
   fix: ~
 

src/snapshots/ruff__linter__tests__D107_D.py.snap

@@ -4,18 +4,18 @@ expression: checks
 ---
 - kind: PublicInit
   location:
-    row: 55
+    row: 60
     column: 4
   end_location:
-    row: 58
+    row: 63
     column: 4
   fix: ~
 - kind: PublicInit
   location:
-    row: 529
+    row: 534
     column: 4
   end_location:
-    row: 533
+    row: 538
     column: 0
   fix: ~
 

src/snapshots/ruff__linter__tests__D201_D.py.snap

@@ -5,69 +5,69 @@ expression: checks
 - kind:
     NoBlankLineBeforeFunction: 1
   location:
-    row: 132
+    row: 137
     column: 4
   end_location:
-    row: 132
+    row: 137
     column: 24
   fix:
     patch:
       content: ""
       location:
-        row: 131
+        row: 136
         column: 0
       end_location:
-        row: 132
+        row: 137
         column: 0
 - kind:
     NoBlankLineBeforeFunction: 1
   location:
-    row: 146
+    row: 151
     column: 4
   end_location:
-    row: 146
+    row: 151
     column: 37
   fix:
     patch:
       content: ""
       location:
-        row: 145
+        row: 150
         column: 0
       end_location:
-        row: 146
+        row: 151
         column: 0
 - kind:
     NoBlankLineBeforeFunction: 1
   location:
-    row: 541
+    row: 546
     column: 4
   end_location:
-    row: 544
+    row: 549
     column: 7
   fix:
     patch:
       content: ""
       location:
-        row: 540
+        row: 545
         column: 0
       end_location:
-        row: 541
+        row: 546
         column: 0
 - kind:
     NoBlankLineBeforeFunction: 1
   location:
-    row: 563
+    row: 568
     column: 4
   end_location:
-    row: 566
+    row: 571
     column: 7
   fix:
     patch:
       content: ""
       location:
-        row: 562
+        row: 567
         column: 0
       end_location:
-        row: 563
+        row: 568
         column: 0
 

src/snapshots/ruff__linter__tests__D202_D.py.snap

@@ -5,69 +5,69 @@ expression: checks
 - kind:
     NoBlankLineAfterFunction: 1
   location:
-    row: 137
+    row: 142
     column: 4
   end_location:
-    row: 137
+    row: 142
     column: 24
   fix:
     patch:
       content: ""
       location:
-        row: 138
+        row: 143
         column: 0
       end_location:
-        row: 139
+        row: 144
         column: 0
 - kind:
     NoBlankLineAfterFunction: 1
   location:
-    row: 146
+    row: 151
     column: 4
   end_location:
-    row: 146
+    row: 151
     column: 37
   fix:
     patch:
       content: ""
       location:
-        row: 147
+        row: 152
         column: 0
       end_location:
-        row: 148
+        row: 153
         column: 0
 - kind:
     NoBlankLineAfterFunction: 1
   location:
-    row: 550
+    row: 555
     column: 4
   end_location:
-    row: 553
+    row: 558
     column: 7
   fix:
     patch:
       content: ""
       location:
-        row: 554
+        row: 559
         column: 0
       end_location:
-        row: 555
+        row: 560
         column: 0
 - kind:
     NoBlankLineAfterFunction: 1
   location:
-    row: 563
+    row: 568
     column: 4
   end_location:
-    row: 566
+    row: 571
     column: 7
   fix:
     patch:
       content: ""
       location:
-        row: 567
+        row: 572
         column: 0
       end_location:
-        row: 568
+        row: 573
         column: 0
 

src/snapshots/ruff__linter__tests__D203_D.py.snap

@@ -5,52 +5,52 @@ expression: checks
 - kind:
     OneBlankLineBeforeClass: 0
   location:
-    row: 156
+    row: 161
     column: 4
   end_location:
-    row: 156
+    row: 161
     column: 32
   fix:
     patch:
       content: "\n"
       location:
-        row: 156
+        row: 161
         column: 0
       end_location:
-        row: 156
+        row: 161
         column: 0
 - kind:
     OneBlankLineBeforeClass: 0
   location:
-    row: 187
+    row: 192
     column: 4
   end_location:
-    row: 187
+    row: 192
     column: 45
   fix:
     patch:
       content: "\n"
       location:
-        row: 187
+        row: 192
         column: 0
       end_location:
-        row: 187
+        row: 192
         column: 0
 - kind:
     OneBlankLineBeforeClass: 0
   location:
-    row: 521
+    row: 526
     column: 4
   end_location:
-    row: 527
+    row: 532
     column: 7
   fix:
     patch:
       content: "\n"
       location:
-        row: 521
+        row: 526
         column: 0
       end_location:
-        row: 521
+        row: 526
         column: 0
 

src/snapshots/ruff__linter__tests__D204_D.py.snap

@@ -5,35 +5,35 @@ expression: checks
 - kind:
     OneBlankLineAfterClass: 0
   location:
-    row: 176
+    row: 181
     column: 4
   end_location:
-    row: 176
+    row: 181
     column: 24
   fix:
     patch:
       content: "\n"
       location:
-        row: 177
+        row: 182
         column: 0
       end_location:
-        row: 177
+        row: 182
         column: 0
 - kind:
     OneBlankLineAfterClass: 0
   location:
-    row: 187
+    row: 192
     column: 4
   end_location:
-    row: 187
+    row: 192
     column: 45
   fix:
     patch:
       content: "\n"
       location:
-        row: 188
+        row: 193
         column: 0
       end_location:
-        row: 188
+        row: 193
         column: 0
 

src/snapshots/ruff__linter__tests__D205_D.py.snap

@@ -4,34 +4,34 @@ expression: checks
 ---
 - kind: BlankLineAfterSummary
   location:
-    row: 195
+    row: 200
     column: 4
   end_location:
-    row: 198
+    row: 203
     column: 7
   fix:
     patch:
       content: "\n"
       location:
-        row: 196
+        row: 201
         column: 0
       end_location:
-        row: 196
+        row: 201
         column: 0
 - kind: BlankLineAfterSummary
   location:
-    row: 205
+    row: 210
     column: 4
   end_location:
-    row: 210
+    row: 215
     column: 7
   fix:
     patch:
       content: "\n"
       location:
-        row: 206
+        row: 211
         column: 0
       end_location:
-        row: 208
+        row: 213
         column: 0
 

src/snapshots/ruff__linter__tests__D207_D.py.snap

@@ -4,34 +4,34 @@ expression: checks
 ---
 - kind: NoUnderIndentation
   location:
-    row: 227
+    row: 232
     column: 0
   end_location:
-    row: 227
+    row: 232
     column: 0
   fix:
     patch:
       content: "    "
       location:
-        row: 227
+        row: 232
         column: 0
       end_location:
-        row: 227
+        row: 232
         column: 0
 - kind: NoUnderIndentation
   location:
-    row: 435
+    row: 440
     column: 0
   end_location:
-    row: 435
+    row: 440
     column: 0
   fix:
     patch:
       content: "                                    "
       location:
-        row: 435
+        row: 440
         column: 0
       end_location:
-        row: 435
+        row: 440
         column: 4
 

src/snapshots/ruff__linter__tests__D208_D.py.snap

@@ -4,50 +4,50 @@ expression: checks
 ---
 - kind: NoOverIndentation
   location:
-    row: 247
+    row: 252
     column: 0
   end_location:
-    row: 247
+    row: 252
     column: 0
   fix:
     patch:
       content: "    "
       location:
-        row: 247
+        row: 252
         column: 0
       end_location:
-        row: 247
+        row: 252
         column: 7
 - kind: NoOverIndentation
   location:
-    row: 259
+    row: 264
     column: 0
   end_location:
-    row: 259
+    row: 264
     column: 0
   fix:
     patch:
       content: "    "
       location:
-        row: 259
+        row: 264
         column: 0
       end_location:
-        row: 259
+        row: 264
         column: 8
 - kind: NoOverIndentation
   location:
-    row: 267
+    row: 272
     column: 0
   end_location:
-    row: 267
+    row: 272
     column: 0
   fix:
     patch:
       content: "    "
       location:
-        row: 267
+        row: 272
         column: 0
       end_location:
-        row: 267
+        row: 272
         column: 8
 

src/snapshots/ruff__linter__tests__D209_D.py.snap

@@ -4,18 +4,18 @@ expression: checks
 ---
 - kind: NewLineAfterLastParagraph
   location:
-    row: 276
+    row: 281
     column: 4
   end_location:
-    row: 278
+    row: 283
     column: 19
   fix:
     patch:
       content: "\n    "
       location:
-        row: 278
+        row: 283
         column: 16
       end_location:
-        row: 278
+        row: 283
         column: 16
 

src/snapshots/ruff__linter__tests__D210_D.py.snap

@@ -4,50 +4,50 @@ expression: checks
 ---
 - kind: NoSurroundingWhitespace
   location:
-    row: 283
+    row: 288
     column: 4
   end_location:
-    row: 283
+    row: 288
     column: 33
   fix:
     patch:
       content: Whitespace at the end.
       location:
-        row: 283
+        row: 288
         column: 7
       end_location:
-        row: 283
+        row: 288
         column: 30
 - kind: NoSurroundingWhitespace
   location:
-    row: 288
+    row: 293
     column: 4
   end_location:
-    row: 288
+    row: 293
     column: 37
   fix:
     patch:
       content: Whitespace at everywhere.
       location:
-        row: 288
+        row: 293
         column: 7
       end_location:
-        row: 288
+        row: 293
         column: 34
 - kind: NoSurroundingWhitespace
   location:
-    row: 294
+    row: 299
     column: 4
   end_location:
-    row: 297
+    row: 302
     column: 7
   fix:
     patch:
       content: Whitespace at the beginning.
       location:
-        row: 294
+        row: 299
         column: 7
       end_location:
-        row: 294
+        row: 299
         column: 36
 

src/snapshots/ruff__linter__tests__D211_D.py.snap

@@ -5,35 +5,35 @@ expression: checks
 - kind:
     NoBlankLineBeforeClass: 1
   location:
-    row: 165
+    row: 170
     column: 4
   end_location:
-    row: 165
+    row: 170
     column: 29
   fix:
     patch:
       content: ""
       location:
-        row: 164
+        row: 169
         column: 0
       end_location:
-        row: 165
+        row: 170
         column: 0
 - kind:
     NoBlankLineBeforeClass: 1
   location:
-    row: 176
+    row: 181
     column: 4
   end_location:
-    row: 176
+    row: 181
     column: 24
   fix:
     patch:
       content: ""
       location:
-        row: 175
+        row: 180
         column: 0
       end_location:
-        row: 176
+        row: 181
         column: 0
 

src/snapshots/ruff__linter__tests__D212_D.py.snap

@@ -4,10 +4,10 @@ expression: checks
 ---
 - kind: MultiLineSummaryFirstLine
   location:
-    row: 124
+    row: 129
     column: 4
   end_location:
-    row: 126
+    row: 131
     column: 7
   fix: ~
 

src/snapshots/ruff__linter__tests__D213_D.py.snap

@@ -4,154 +4,154 @@ expression: checks
 ---
 - kind: MultiLineSummarySecondLine
   location:
-    row: 195
+    row: 200
     column: 4
   end_location:
-    row: 198
+    row: 203
     column: 7
   fix: ~
 - kind: MultiLineSummarySecondLine
   location:
-    row: 205
-    column: 4
-  end_location:
     row: 210
-    column: 7
-  fix: ~
-- kind: MultiLineSummarySecondLine
-  location:
+    column: 4
+  end_location:
     row: 215
-    column: 4
-  end_location:
-    row: 219
     column: 7
   fix: ~
 - kind: MultiLineSummarySecondLine
   location:
-    row: 225
+    row: 220
     column: 4
   end_location:
-    row: 229
+    row: 224
     column: 7
   fix: ~
 - kind: MultiLineSummarySecondLine
   location:
-    row: 235
+    row: 230
     column: 4
   end_location:
-    row: 239
+    row: 234
+    column: 7
+  fix: ~
+- kind: MultiLineSummarySecondLine
+  location:
+    row: 240
+    column: 4
+  end_location:
+    row: 244
     column: 3
   fix: ~
 - kind: MultiLineSummarySecondLine
   location:
-    row: 245
+    row: 250
     column: 4
   end_location:
-    row: 249
+    row: 254
     column: 7
   fix: ~
 - kind: MultiLineSummarySecondLine
   location:
-    row: 255
+    row: 260
     column: 4
   end_location:
-    row: 259
+    row: 264
     column: 11
   fix: ~
 - kind: MultiLineSummarySecondLine
   location:
-    row: 265
+    row: 270
     column: 4
   end_location:
-    row: 269
+    row: 274
     column: 7
   fix: ~
 - kind: MultiLineSummarySecondLine
   location:
-    row: 276
+    row: 281
     column: 4
   end_location:
-    row: 278
+    row: 283
     column: 19
   fix: ~
 - kind: MultiLineSummarySecondLine
   location:
-    row: 294
+    row: 299
     column: 4
   end_location:
-    row: 297
+    row: 302
     column: 7
   fix: ~
 - kind: MultiLineSummarySecondLine
   location:
-    row: 338
-    column: 4
-  end_location:
     row: 343
-    column: 7
-  fix: ~
-- kind: MultiLineSummarySecondLine
-  location:
-    row: 378
     column: 4
   end_location:
-    row: 381
+    row: 348
     column: 7
   fix: ~
 - kind: MultiLineSummarySecondLine
   location:
-    row: 387
+    row: 383
     column: 4
   end_location:
-    row: 391
+    row: 386
     column: 7
   fix: ~
 - kind: MultiLineSummarySecondLine
   location:
-    row: 433
+    row: 392
+    column: 4
+  end_location:
+    row: 396
+    column: 7
+  fix: ~
+- kind: MultiLineSummarySecondLine
+  location:
+    row: 438
     column: 36
   end_location:
-    row: 436
+    row: 441
     column: 7
   fix: ~
 - kind: MultiLineSummarySecondLine
   location:
-    row: 445
+    row: 450
     column: 4
   end_location:
-    row: 449
+    row: 454
     column: 7
   fix: ~
 - kind: MultiLineSummarySecondLine
   location:
-    row: 521
+    row: 526
     column: 4
   end_location:
-    row: 527
+    row: 532
     column: 7
   fix: ~
 - kind: MultiLineSummarySecondLine
   location:
-    row: 541
+    row: 546
     column: 4
   end_location:
-    row: 544
+    row: 549
     column: 7
   fix: ~
 - kind: MultiLineSummarySecondLine
   location:
-    row: 550
+    row: 555
     column: 4
   end_location:
-    row: 553
+    row: 558
     column: 7
   fix: ~
 - kind: MultiLineSummarySecondLine
   location:
-    row: 563
+    row: 568
     column: 4
   end_location:
-    row: 566
+    row: 571
     column: 7
   fix: ~
 

src/snapshots/ruff__linter__tests__D300_D.py.snap

@@ -2,14 +2,6 @@
 source: src/linter.rs
 expression: checks
 ---
-- kind: UsesTripleQuotes
-  location:
-    row: 302
-    column: 4
-  end_location:
-    row: 302
-    column: 19
-  fix: ~
 - kind: UsesTripleQuotes
   location:
     row: 307
@@ -24,7 +16,7 @@ expression: checks
     column: 4
   end_location:
     row: 312
-    column: 15
+    column: 19
   fix: ~
 - kind: UsesTripleQuotes
   location:
@@ -36,10 +28,18 @@ expression: checks
   fix: ~
 - kind: UsesTripleQuotes
   location:
-    row: 323
+    row: 322
     column: 4
   end_location:
-    row: 323
+    row: 322
+    column: 15
+  fix: ~
+- kind: UsesTripleQuotes
+  location:
+    row: 328
+    column: 4
+  end_location:
+    row: 328
     column: 16
   fix: ~
 

src/snapshots/ruff__linter__tests__D400_D.py.snap

@@ -4,60 +4,52 @@ expression: checks
 ---
 - kind: EndsInPeriod
   location:
-    row: 350
+    row: 355
     column: 4
   end_location:
-    row: 350
+    row: 355
     column: 17
   fix: ~
 - kind: EndsInPeriod
   location:
-    row: 401
+    row: 406
     column: 24
   end_location:
-    row: 401
+    row: 406
     column: 39
   fix: ~
 - kind: EndsInPeriod
   location:
-    row: 405
+    row: 410
     column: 4
   end_location:
-    row: 405
+    row: 410
     column: 24
   fix: ~
 - kind: EndsInPeriod
   location:
-    row: 411
+    row: 416
     column: 4
   end_location:
-    row: 411
+    row: 416
     column: 24
   fix: ~
 - kind: EndsInPeriod
   location:
-    row: 417
+    row: 422
     column: 34
   end_location:
-    row: 417
+    row: 422
     column: 49
   fix: ~
 - kind: EndsInPeriod
   location:
-    row: 424
+    row: 429
     column: 48
   end_location:
-    row: 424
+    row: 429
     column: 63
   fix: ~
-- kind: EndsInPeriod
-  location:
-    row: 465
-    column: 4
-  end_location:
-    row: 465
-    column: 24
-  fix: ~
 - kind: EndsInPeriod
   location:
     row: 470
@@ -76,34 +68,42 @@ expression: checks
   fix: ~
 - kind: EndsInPeriod
   location:
-    row: 482
+    row: 480
     column: 4
   end_location:
-    row: 482
+    row: 480
     column: 24
   fix: ~
 - kind: EndsInPeriod
   location:
-    row: 504
+    row: 487
     column: 4
   end_location:
-    row: 504
+    row: 487
+    column: 24
+  fix: ~
+- kind: EndsInPeriod
+  location:
+    row: 509
+    column: 4
+  end_location:
+    row: 509
     column: 34
   fix: ~
 - kind: EndsInPeriod
   location:
-    row: 509
+    row: 514
     column: 4
   end_location:
-    row: 509
+    row: 514
     column: 33
   fix: ~
 - kind: EndsInPeriod
   location:
-    row: 515
+    row: 520
     column: 4
   end_location:
-    row: 515
+    row: 520
     column: 32
   fix: ~
 

src/snapshots/ruff__linter__tests__D402_D.py.snap

@@ -4,10 +4,10 @@ expression: checks
 ---
 - kind: NoSignature
   location:
-    row: 373
+    row: 378
     column: 4
   end_location:
-    row: 373
+    row: 378
     column: 30
   fix: ~
 

src/snapshots/ruff__linter__tests__D415_D.py.snap

@@ -4,60 +4,52 @@ expression: checks
 ---
 - kind: EndsInPunctuation
   location:
-    row: 350
+    row: 355
     column: 4
   end_location:
-    row: 350
+    row: 355
     column: 17
   fix: ~
 - kind: EndsInPunctuation
   location:
-    row: 401
+    row: 406
     column: 24
   end_location:
-    row: 401
+    row: 406
     column: 39
   fix: ~
 - kind: EndsInPunctuation
   location:
-    row: 405
+    row: 410
     column: 4
   end_location:
-    row: 405
+    row: 410
     column: 24
   fix: ~
 - kind: EndsInPunctuation
   location:
-    row: 411
+    row: 416
     column: 4
   end_location:
-    row: 411
+    row: 416
     column: 24
   fix: ~
 - kind: EndsInPunctuation
   location:
-    row: 417
+    row: 422
     column: 34
   end_location:
-    row: 417
+    row: 422
     column: 49
   fix: ~
 - kind: EndsInPunctuation
   location:
-    row: 424
+    row: 429
     column: 48
   end_location:
-    row: 424
+    row: 429
     column: 63
   fix: ~
-- kind: EndsInPunctuation
-  location:
-    row: 465
-    column: 4
-  end_location:
-    row: 465
-    column: 24
-  fix: ~
 - kind: EndsInPunctuation
   location:
     row: 470
@@ -76,26 +68,34 @@ expression: checks
   fix: ~
 - kind: EndsInPunctuation
   location:
-    row: 482
+    row: 480
     column: 4
   end_location:
-    row: 482
+    row: 480
     column: 24
   fix: ~
 - kind: EndsInPunctuation
   location:
-    row: 504
+    row: 487
     column: 4
   end_location:
-    row: 504
+    row: 487
+    column: 24
+  fix: ~
+- kind: EndsInPunctuation
+  location:
+    row: 509
+    column: 4
+  end_location:
+    row: 509
     column: 34
   fix: ~
 - kind: EndsInPunctuation
   location:
-    row: 515
+    row: 520
     column: 4
   end_location:
-    row: 515
+    row: 520
     column: 32
   fix: ~
 

src/snapshots/ruff__linter__tests__D418_D.py.snap

@@ -4,26 +4,26 @@ expression: checks
 ---
 - kind: SkipDocstring
   location:
-    row: 33
+    row: 34
     column: 4
   end_location:
-    row: 37
+    row: 38
     column: 4
   fix: ~
 - kind: SkipDocstring
   location:
-    row: 85
+    row: 90
     column: 4
   end_location:
-    row: 89
+    row: 94
     column: 4
   fix: ~
 - kind: SkipDocstring
   location:
-    row: 105
+    row: 110
     column: 0
   end_location:
-    row: 110
+    row: 115
     column: 0
   fix: ~
 

src/snapshots/ruff__linter__tests__D419_D.py.snap

@@ -4,26 +4,26 @@ expression: checks
 ---
 - kind: NonEmpty
   location:
-    row: 19
+    row: 20
     column: 8
   end_location:
-    row: 19
+    row: 20
     column: 14
   fix: ~
 - kind: NonEmpty
   location:
-    row: 69
+    row: 74
     column: 4
   end_location:
-    row: 69
+    row: 74
     column: 11
   fix: ~
 - kind: NonEmpty
   location:
-    row: 75
+    row: 80
     column: 8
   end_location:
-    row: 75
+    row: 80
     column: 10
   fix: ~
 

src/snapshots/ruff__linter__tests__F501_F50x.py.snap

@@ -0,0 +1,14 @@
+---
+source: src/linter.rs
+expression: checks
+---
+- kind:
+    PercentFormatInvalidFormat: incomplete format
+  location:
+    row: 1
+    column: 9
+  end_location:
+    row: 1
+    column: 25
+  fix: ~
+

src/snapshots/ruff__linter__tests__F502_F502.py.snap

@@ -0,0 +1,61 @@
+---
+source: src/linter.rs
+expression: checks
+---
+- kind: PercentFormatExpectedMapping
+  location:
+    row: 6
+    column: 10
+  end_location:
+    row: 6
+    column: 19
+  fix: ~
+- kind: PercentFormatExpectedMapping
+  location:
+    row: 7
+    column: 10
+  end_location:
+    row: 7
+    column: 20
+  fix: ~
+- kind: PercentFormatExpectedMapping
+  location:
+    row: 8
+    column: 10
+  end_location:
+    row: 8
+    column: 19
+  fix: ~
+- kind: PercentFormatExpectedMapping
+  location:
+    row: 9
+    column: 10
+  end_location:
+    row: 9
+    column: 22
+  fix: ~
+- kind: PercentFormatExpectedMapping
+  location:
+    row: 11
+    column: 10
+  end_location:
+    row: 11
+    column: 37
+  fix: ~
+- kind: PercentFormatExpectedMapping
+  location:
+    row: 12
+    column: 10
+  end_location:
+    row: 12
+    column: 37
+  fix: ~
+- kind: PercentFormatExpectedMapping
+  location:
+    row: 13
+    column: 10
+  end_location:
+    row: 13
+    column: 37
+  fix: ~
+

src/snapshots/ruff__linter__tests__F502_F50x.py.snap

@@ -0,0 +1,13 @@
+---
+source: src/linter.rs
+expression: checks
+---
+- kind: PercentFormatExpectedMapping
+  location:
+    row: 9
+    column: 10
+  end_location:
+    row: 9
+    column: 21
+  fix: ~
+

src/snapshots/ruff__linter__tests__F503_F503.py.snap

@@ -0,0 +1,29 @@
+---
+source: src/linter.rs
+expression: checks
+---
+- kind: PercentFormatExpectedSequence
+  location:
+    row: 17
+    column: 8
+  end_location:
+    row: 17
+    column: 24
+  fix: ~
+- kind: PercentFormatExpectedSequence
+  location:
+    row: 18
+    column: 8
+  end_location:
+    row: 18
+    column: 28
+  fix: ~
+- kind: PercentFormatExpectedSequence
+  location:
+    row: 23
+    column: 8
+  end_location:
+    row: 23
+    column: 42
+  fix: ~
+

src/snapshots/ruff__linter__tests__F503_F50x.py.snap

@@ -0,0 +1,13 @@
+---
+source: src/linter.rs
+expression: checks
+---
+- kind: PercentFormatExpectedSequence
+  location:
+    row: 10
+    column: 8
+  end_location:
+    row: 10
+    column: 20
+  fix: ~
+

src/snapshots/ruff__linter__tests__F504_F504.py.snap

@@ -0,0 +1,15 @@
+---
+source: src/linter.rs
+expression: checks
+---
+- kind:
+    PercentFormatExtraNamedArguments:
+      - b
+  location:
+    row: 3
+    column: 14
+  end_location:
+    row: 3
+    column: 34
+  fix: ~
+

src/snapshots/ruff__linter__tests__F504_F50x.py.snap

@@ -0,0 +1,15 @@
+---
+source: src/linter.rs
+expression: checks
+---
+- kind:
+    PercentFormatExtraNamedArguments:
+      - baz
+  location:
+    row: 8
+    column: 10
+  end_location:
+    row: 8
+    column: 32
+  fix: ~
+

src/snapshots/ruff__linter__tests__F505_F504.py.snap

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

src/snapshots/ruff__linter__tests__F505_F50x.py.snap

@@ -0,0 +1,15 @@
+---
+source: src/linter.rs
+expression: checks
+---
+- kind:
+    PercentFormatMissingArgument:
+      - bar
+  location:
+    row: 7
+    column: 10
+  end_location:
+    row: 7
+    column: 14
+  fix: ~
+

src/snapshots/ruff__linter__tests__F506_F50x.py.snap

@@ -0,0 +1,29 @@
+---
+source: src/linter.rs
+expression: checks
+---
+- kind: PercentFormatMixedPositionalAndNamed
+  location:
+    row: 2
+    column: 13
+  end_location:
+    row: 2
+    column: 29
+  fix: ~
+- kind: PercentFormatMixedPositionalAndNamed
+  location:
+    row: 3
+    column: 13
+  end_location:
+    row: 3
+    column: 29
+  fix: ~
+- kind: PercentFormatMixedPositionalAndNamed
+  location:
+    row: 11
+    column: 11
+  end_location:
+    row: 11
+    column: 27
+  fix: ~
+

src/snapshots/ruff__linter__tests__F507_F50x.py.snap

@@ -0,0 +1,27 @@
+---
+source: src/linter.rs
+expression: checks
+---
+- kind:
+    PercentFormatPositionalCountMismatch:
+      - 2
+      - 1
+  location:
+    row: 5
+    column: 8
+  end_location:
+    row: 5
+    column: 14
+  fix: ~
+- kind:
+    PercentFormatPositionalCountMismatch:
+      - 2
+      - 3
+  location:
+    row: 6
+    column: 8
+  end_location:
+    row: 6
+    column: 19
+  fix: ~
+

src/snapshots/ruff__linter__tests__F508_F50x.py.snap

@@ -0,0 +1,13 @@
+---
+source: src/linter.rs
+expression: checks
+---
+- kind: PercentFormatStarRequiresSequence
+  location:
+    row: 11
+    column: 11
+  end_location:
+    row: 11
+    column: 27
+  fix: ~
+

src/snapshots/ruff__linter__tests__F509_F50x.py.snap

@@ -0,0 +1,14 @@
+---
+source: src/linter.rs
+expression: checks
+---
+- kind:
+    PercentFormatUnsupportedFormatCharacter: j
+  location:
+    row: 4
+    column: 5
+  end_location:
+    row: 4
+    column: 11
+  fix: ~
+

src/snapshots/ruff__linter__tests__FBT003_FBT.py.snap

@@ -4,10 +4,26 @@ expression: checks
 ---
 - kind: BooleanPositionalValueInFunctionCall
   location:
-    row: 41
+    row: 42
     column: 10
   end_location:
-    row: 41
+    row: 42
     column: 14
   fix: ~
+- kind: BooleanPositionalValueInFunctionCall
+  location:
+    row: 57
+    column: 10
+  end_location:
+    row: 57
+    column: 14
+  fix: ~
+- kind: BooleanPositionalValueInFunctionCall
+  location:
+    row: 57
+    column: 16
+  end_location:
+    row: 57
+    column: 21
+  fix: ~
 

src/vendored/cformat.rs

@@ -0,0 +1,413 @@
+//! Implementation of Printf-Style string formatting
+//! as per the [Python Docs](https://docs.python.org/3/library/stdtypes.html#printf-style-string-formatting).
+//! Vendored from [cformat.rs in rustpython-vm](https://github.com/RustPython/RustPython/blob/f54b5556e28256763c5506813ea977c9e1445af0/vm/src/cformat.rs).
+//! The only changes we make are to remove dead code and code involving the vm.
+use std::fmt;
+use std::iter::{Enumerate, Peekable};
+use std::str::FromStr;
+
+#[derive(Debug, PartialEq)]
+pub(crate) enum CFormatErrorType {
+    UnmatchedKeyParentheses,
+    MissingModuloSign,
+    UnsupportedFormatChar(char),
+    IncompleteFormat,
+    IntTooBig,
+    // Unimplemented,
+}
+
+// also contains how many chars the parsing function consumed
+type ParsingError = (CFormatErrorType, usize);
+
+#[derive(Debug, PartialEq)]
+pub(crate) struct CFormatError {
+    pub(crate) typ: CFormatErrorType,
+    index: usize,
+}
+
+impl fmt::Display for CFormatError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        use CFormatErrorType::{
+            IntTooBig, MissingModuloSign, UnmatchedKeyParentheses, UnsupportedFormatChar,
+        };
+        match self.typ {
+            UnmatchedKeyParentheses => write!(f, "incomplete format key"),
+            CFormatErrorType::IncompleteFormat => write!(f, "incomplete format"),
+            UnsupportedFormatChar(c) => write!(
+                f,
+                "unsupported format character '{}' ({:#x}) at index {}",
+                c, c as u32, self.index
+            ),
+            IntTooBig => write!(f, "width/precision too big"),
+            MissingModuloSign => write!(f, "unexpected error parsing format string"),
+        }
+    }
+}
+
+#[derive(Debug, PartialEq)]
+pub(crate) enum CFormatQuantity {
+    Amount(usize),
+    FromValuesTuple,
+}
+
+#[derive(Debug, PartialEq)]
+pub(crate) struct CFormatSpec {
+    pub mapping_key: Option<String>,
+    pub min_field_width: Option<CFormatQuantity>,
+    pub precision: Option<CFormatQuantity>,
+}
+
+impl CFormatSpec {
+    fn parse<T, I>(iter: &mut ParseIter<I>) -> Result<Self, ParsingError>
+    where
+        T: Into<char> + Copy,
+        I: Iterator<Item = T>,
+    {
+        let mapping_key = parse_spec_mapping_key(iter)?;
+        consume_flags(iter);
+        let min_field_width = parse_quantity(iter)?;
+        let precision = parse_precision(iter)?;
+        consume_length(iter);
+        parse_format_type(iter)?;
+
+        Ok(CFormatSpec {
+            mapping_key,
+            min_field_width,
+            precision,
+        })
+    }
+}
+
+#[derive(Debug, PartialEq)]
+pub(crate) enum CFormatPart<T> {
+    Literal(T),
+    Spec(CFormatSpec),
+}
+
+#[derive(Debug, PartialEq)]
+pub(crate) struct CFormatString {
+    pub parts: Vec<(usize, CFormatPart<String>)>,
+}
+
+impl FromStr for CFormatString {
+    type Err = CFormatError;
+
+    fn from_str(text: &str) -> Result<Self, Self::Err> {
+        let mut iter = text.chars().enumerate().peekable();
+        Self::parse(&mut iter)
+    }
+}
+
+impl CFormatString {
+    pub(crate) fn parse<I: Iterator<Item = char>>(
+        iter: &mut ParseIter<I>,
+    ) -> Result<Self, CFormatError> {
+        let mut parts = vec![];
+        let mut literal = String::new();
+        let mut part_index = 0;
+        while let Some((index, c)) = iter.next() {
+            if c == '%' {
+                if let Some(&(_, second)) = iter.peek() {
+                    if second == '%' {
+                        iter.next().unwrap();
+                        literal.push('%');
+                        continue;
+                    }
+                    if !literal.is_empty() {
+                        parts.push((
+                            part_index,
+                            CFormatPart::Literal(std::mem::take(&mut literal)),
+                        ));
+                    }
+                    let spec = CFormatSpec::parse(iter).map_err(|err| CFormatError {
+                        typ: err.0,
+                        index: err.1,
+                    })?;
+                    parts.push((index, CFormatPart::Spec(spec)));
+                    if let Some(&(index, _)) = iter.peek() {
+                        part_index = index;
+                    }
+                } else {
+                    return Err(CFormatError {
+                        typ: CFormatErrorType::IncompleteFormat,
+                        index: index + 1,
+                    });
+                }
+            } else {
+                literal.push(c);
+            }
+        }
+        if !literal.is_empty() {
+            parts.push((part_index, CFormatPart::Literal(literal)));
+        }
+        Ok(Self { parts })
+    }
+}
+
+type ParseIter<I> = Peekable<Enumerate<I>>;
+
+fn parse_quantity<T, I>(iter: &mut ParseIter<I>) -> Result<Option<CFormatQuantity>, ParsingError>
+where
+    T: Into<char> + Copy,
+    I: Iterator<Item = T>,
+{
+    #![allow(clippy::cast_possible_wrap)] // A single digit will never overflow
+
+    if let Some(&(_, c)) = iter.peek() {
+        let c: char = c.into();
+        if c == '*' {
+            iter.next().unwrap();
+            return Ok(Some(CFormatQuantity::FromValuesTuple));
+        }
+        if let Some(i) = c.to_digit(10) {
+            let mut num = i as i32;
+            iter.next().unwrap();
+            while let Some(&(index, c)) = iter.peek() {
+                if let Some(i) = c.into().to_digit(10) {
+                    num = num
+                        .checked_mul(10)
+                        .and_then(|num| num.checked_add(i as i32))
+                        .ok_or((CFormatErrorType::IntTooBig, index))?;
+                    iter.next().unwrap();
+                } else {
+                    break;
+                }
+            }
+            return Ok(Some(CFormatQuantity::Amount(num.unsigned_abs() as usize)));
+        }
+    }
+    Ok(None)
+}
+
+fn parse_precision<T, I>(iter: &mut ParseIter<I>) -> Result<Option<CFormatQuantity>, ParsingError>
+where
+    T: Into<char> + Copy,
+    I: Iterator<Item = T>,
+{
+    if let Some(&(_, c)) = iter.peek() {
+        if c.into() == '.' {
+            iter.next().unwrap();
+            return parse_quantity(iter);
+        }
+    }
+    Ok(None)
+}
+
+fn parse_text_inside_parentheses<T, I>(iter: &mut ParseIter<I>) -> Option<String>
+where
+    T: Into<char>,
+    I: Iterator<Item = T>,
+{
+    let mut counter: i32 = 1;
+    let mut contained_text = String::new();
+    loop {
+        let (_, c) = iter.next()?;
+        let c = c.into();
+        match c {
+            _ if c == '(' => {
+                counter += 1;
+            }
+            _ if c == ')' => {
+                counter -= 1;
+            }
+            _ => (),
+        }
+
+        if counter > 0 {
+            contained_text.push(c);
+        } else {
+            break;
+        }
+    }
+
+    Some(contained_text)
+}
+
+fn parse_spec_mapping_key<T, I>(iter: &mut ParseIter<I>) -> Result<Option<String>, ParsingError>
+where
+    T: Into<char> + Copy,
+    I: Iterator<Item = T>,
+{
+    if let Some(&(index, c)) = iter.peek() {
+        if c.into() == '(' {
+            iter.next().unwrap();
+            return match parse_text_inside_parentheses(iter) {
+                Some(key) => Ok(Some(key)),
+                None => Err((CFormatErrorType::UnmatchedKeyParentheses, index)),
+            };
+        }
+    }
+    Ok(None)
+}
+
+fn consume_flags<T, I>(iter: &mut ParseIter<I>)
+where
+    T: Into<char> + Copy,
+    I: Iterator<Item = T>,
+{
+    while let Some(&(_, c)) = iter.peek() {
+        match c.into() {
+            '#' | '0' | '-' | ' ' | '+' => {
+                iter.next().unwrap();
+                continue;
+            }
+            _ => break,
+        };
+    }
+}
+
+fn consume_length<T, I>(iter: &mut ParseIter<I>)
+where
+    T: Into<char> + Copy,
+    I: Iterator<Item = T>,
+{
+    if let Some(&(_, c)) = iter.peek() {
+        let c = c.into();
+        if c == 'h' || c == 'l' || c == 'L' {
+            iter.next().unwrap();
+        }
+    }
+}
+
+fn parse_format_type<T, I>(iter: &mut ParseIter<I>) -> Result<(), ParsingError>
+where
+    T: Into<char>,
+    I: Iterator<Item = T>,
+{
+    let (index, c) = match iter.next() {
+        Some((index, c)) => (index, c.into()),
+        None => {
+            return Err((
+                CFormatErrorType::IncompleteFormat,
+                iter.peek().map_or(0, |x| x.0),
+            ));
+        }
+    };
+    match c {
+        'd' | 'i' | 'u' | 'o' | 'x' | 'X' | 'e' | 'E' | 'f' | 'F' | 'g' | 'G' | 'c' | 'r' | 's'
+        | 'b' | 'a' => Ok(()),
+        _ => Err((CFormatErrorType::UnsupportedFormatChar(c), index)),
+    }
+}
+
+impl FromStr for CFormatSpec {
+    type Err = ParsingError;
+
+    fn from_str(text: &str) -> Result<Self, Self::Err> {
+        let mut chars = text.chars().enumerate().peekable();
+        if chars.next().map(|x| x.1) != Some('%') {
+            return Err((CFormatErrorType::MissingModuloSign, 1));
+        }
+
+        CFormatSpec::parse(&mut chars)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_parse_key() {
+        let expected = Ok(CFormatSpec {
+            mapping_key: Some("amount".to_owned()),
+            min_field_width: None,
+            precision: None,
+        });
+        assert_eq!("%(amount)d".parse::<CFormatSpec>(), expected);
+
+        let expected = Ok(CFormatSpec {
+            mapping_key: Some("m((u(((l((((ti))))p)))l))e".to_owned()),
+            min_field_width: None,
+            precision: None,
+        });
+        assert_eq!(
+            "%(m((u(((l((((ti))))p)))l))e)d".parse::<CFormatSpec>(),
+            expected
+        );
+    }
+
+    #[test]
+    fn test_format_parse_key_fail() {
+        assert_eq!(
+            "%(aged".parse::<CFormatString>(),
+            Err(CFormatError {
+                typ: CFormatErrorType::UnmatchedKeyParentheses,
+                index: 1
+            })
+        );
+    }
+
+    #[test]
+    fn test_format_parse_type_fail() {
+        assert_eq!(
+            "Hello %n".parse::<CFormatString>(),
+            Err(CFormatError {
+                typ: CFormatErrorType::UnsupportedFormatChar('n'),
+                index: 7
+            })
+        );
+    }
+
+    #[test]
+    fn test_incomplete_format_fail() {
+        assert_eq!(
+            "Hello %".parse::<CFormatString>(),
+            Err(CFormatError {
+                typ: CFormatErrorType::IncompleteFormat,
+                index: 7
+            })
+        );
+    }
+
+    #[test]
+    fn test_consume_flags() {
+        let expected = Ok(CFormatSpec {
+            min_field_width: Some(CFormatQuantity::Amount(10)),
+            precision: None,
+            mapping_key: None,
+        });
+        let parsed = "%  0   -+++###10d".parse::<CFormatSpec>();
+        assert_eq!(parsed, expected);
+    }
+
+    #[test]
+    fn test_parse_string() {
+        assert!("%5.4s".parse::<CFormatSpec>().is_ok());
+        assert!("%-5.4s".parse::<CFormatSpec>().is_ok());
+    }
+
+    #[test]
+    fn test_format_parse() {
+        let fmt = "Hello, my name is %s and I'm %d years old";
+        let expected = Ok(CFormatString {
+            parts: vec![
+                (0, CFormatPart::Literal("Hello, my name is ".to_owned())),
+                (
+                    18,
+                    CFormatPart::Spec(CFormatSpec {
+                        mapping_key: None,
+                        min_field_width: None,
+                        precision: None,
+                    }),
+                ),
+                (20, CFormatPart::Literal(" and I'm ".to_owned())),
+                (
+                    29,
+                    CFormatPart::Spec(CFormatSpec {
+                        mapping_key: None,
+                        min_field_width: None,
+                        precision: None,
+                    }),
+                ),
+                (31, CFormatPart::Literal(" years old".to_owned())),
+            ],
+        });
+        let result = fmt.parse::<CFormatString>();
+        assert_eq!(
+            result, expected,
+            "left = {:#?} \n\n\n right = {:#?}",
+            result, expected
+        );
+    }
+}

src/vendored/mod.rs

@@ -1 +1,2 @@
+pub mod cformat;
 pub mod format;

src/visibility.rs

@@ -60,6 +60,17 @@ pub fn is_overload(stmt: &Stmt) -> bool {
     }
 }
 
+/// Returns `true` if a function definition is an `@override` (PEP 698).
+pub fn is_override(stmt: &Stmt) -> bool {
+    match &stmt.node {
+        StmtKind::FunctionDef { decorator_list, .. }
+        | StmtKind::AsyncFunctionDef { decorator_list, .. } => decorator_list
+            .iter()
+            .any(|expr| match_name_or_attr(expr, "override")),
+        _ => panic!("Found non-FunctionDef in is_override"),
+    }
+}
+
 /// Returns `true` if a function is a "magic method".
 pub fn is_magic(stmt: &Stmt) -> bool {
     match &stmt.node {