Bump version to 0.0.107

.cargo/config.toml

@@ -0,0 +1,2 @@
+[alias]
+dev = "run --package ruff_dev --bin ruff_dev"

.pre-commit-config.yaml

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

CONTRIBUTING.md

@@ -1,17 +1,17 @@
-# Contributing to ruff
+# Contributing to Ruff
 
-Welcome! We're happy to have you here. Thank you in advance for your contribution to ruff.
+Welcome! We're happy to have you here. Thank you in advance for your contribution to Ruff.
 
 ## The basics
 
-ruff welcomes contributions in the form of Pull Requests. For small changes (e.g., bug fixes), feel
+Ruff welcomes contributions in the form of Pull Requests. For small changes (e.g., bug fixes), feel
 free to submit a PR. For larger changes (e.g., new lint rules, new functionality, new configuration
 options), consider submitting an [Issue](https://github.com/charliermarsh/ruff/issues) outlining
 your proposed change.
 
 ### Prerequisites
 
-ruff is written in Rust (1.63.0). You'll need to install the
+Ruff is written in Rust. You'll need to install the
 [Rust toolchain](https://www.rust-lang.org/tools/install) for development.
 
 You'll also need [Insta](https://insta.rs/docs/) to update snapshot tests:
@@ -22,7 +22,7 @@ cargo install cargo-insta
 
 ### Development
 
-After cloning the repository, run ruff locally with:
+After cloning the repository, run Ruff locally with:
 
 ```shell
 cargo run resources/test/fixtures --no-cache
@@ -32,9 +32,9 @@ Prior to opening a pull request, ensure that your code has been auto-formatted,
 both the lint and test validation checks:
 
 ```shell
-cargo fmt     # Auto-formatting...
-cargo clippy  # Linting...
-cargo test    # Testing...
+cargo +nightly fmt --all     # Auto-formatting...
+cargo +nightly clippy --all  # Linting...
+cargo +nightly test --all    # Testing...
 ```
 
 These checks will run on GitHub Actions when you open your Pull Request, but running them locally
@@ -45,12 +45,13 @@ prior to merging.
 
 ### Example: Adding a new lint rule
 
-There are three phases to adding a new lint rule:
+There are four phases to adding a new lint rule:
 
 1. Define the rule in `src/checks.rs`.
-2. Define the _logic_ for triggering the rule in `src/check_ast.rs` (for AST-based checks)
-   or `src/check_lines.rs` (for text-based checks).
+2. Define the _logic_ for triggering the rule in `src/check_ast.rs` (for AST-based checks),
+   `src/check_tokens.rs` (for token-based checks), or `src/check_lines.rs` (for text-based checks).
 3. Add a test fixture.
+4. Update the generated files (documentation and generated code).
 
 To define the rule, open up `src/checks.rs`. You'll need to define both a `CheckCode` and
 `CheckKind`. As an example, you can grep for `E402` and `ModuleImportNotAtTopOfFile`, and follow the
@@ -58,37 +59,33 @@ pattern implemented therein.
 
 To trigger the rule, you'll likely want to augment the logic in `src/check_ast.rs`, which defines
 the Python AST visitor, responsible for iterating over the abstract syntax tree and collecting
-lint-rule violations as it goes. Grep for the `Check::new` invocations to understand how other,
-similar rules are implemented.
+lint-rule violations as it goes. If you need to inspect the AST, you can run `cargo dev print-ast`
+with a Python file. Grep for the `Check::new` invocations to understand how other, similar rules
+are implemented.
 
 To add a test fixture, create a file under `resources/test/fixtures`, named to match the `CheckCode`
 you defined earlier (e.g., `E402.py`). This file should contain a variety of violations and
-non-violations designed to evaluate and demonstrate the behavior of your lint rule. Run ruff locally
-with (e.g.) `cargo run resources/test/fixtures/E402.py`. Once you're satisfied with the output,
-codify the behavior as a snapshot test by adding a new function to the `mod tests` section of
-`src/linter.rs`, like so:
+non-violations designed to evaluate and demonstrate the behavior of your lint rule. Run Ruff locally
+with (e.g.) `cargo run resources/test/fixtures/E402.py --no-cache`. Once you're satisfied with the
+output, codify the behavior as a snapshot test by adding a new `testcase` macro to the `mod tests`
+section of `src/linter.rs`, like so:
 
 ```rust
-#[test]
-fn e402() -> Result<()> {
-    let mut checks = check_path(
-        Path::new("./resources/test/fixtures/E402.py"),
-        &settings::Settings::for_rule(CheckCode::E402),
-        &fixer::Mode::Generate,
-    )?;
-    checks.sort_by_key(|check| check.location);
-    insta::assert_yaml_snapshot!(checks);
-    Ok(())
-}
+#[test_case(CheckCode::A001, Path::new("A001.py"); "A001")]
+...
 ```
 
 Then, run `cargo test`. Your test will fail, but you'll be prompted to follow-up with
 `cargo insta review`. Accept the generated snapshot, then commit the snapshot file alongside the
 rest of your changes.
 
+Finally, to update the documentation, run `cargo dev generate-rules-table` from the repo root. To
+update the generated prefix map, run `cargo dev generate-check-code-prefix`. Both of these commands
+should be run whenever a new check is added to the codebase.
+
 ### Example: Adding a new configuration option
 
-ruff's user-facing settings live in two places: first, the command-line options defined with
+Ruff's user-facing settings live in two places: first, the command-line options defined with
 [clap](https://docs.rs/clap/latest/clap/) via the `Cli` struct in `src/main.rs`; and second, the
 `Config` struct defined `src/pyproject.rs`, which is responsible for extracting user-defined
 settings from a `pyproject.toml` file.
@@ -103,9 +100,9 @@ acceptable unused variables (e.g., `_`).
 
 ## Release process
 
-As of now, ruff has an ad hoc release process: releases are cut with high frequency via GitHub
+As of now, Ruff has an ad hoc release process: releases are cut with high frequency via GitHub
 Actions, which automatically generates the appropriate wheels across architectures and publishes
 them to [PyPI](https://pypi.org/project/ruff/).
 
-ruff follows the [semver](https://semver.org/) versioning standard. However, as pre-1.0 software,
+Ruff follows the [semver](https://semver.org/) versioning standard. However, as pre-1.0 software,
 even patch releases may contain [non-backwards-compatible changes](https://semver.org/#spec-item-4).

Cargo.lock

@@ -920,7 +920,7 @@ checksum = "0ce7134b9999ecaf8bcd65542e436736ef32ddca1b3e06094cb6ec5755203b80"
 
 [[package]]
 name = "flake8-to-ruff"
-version = "0.0.99-dev.0"
+version = "0.0.107-dev.0"
 dependencies = [
  "anyhow",
  "clap 4.0.15",
@@ -2209,9 +2209,19 @@ dependencies = [
  "winapi 0.3.9",
 ]
 
+[[package]]
+name = "ropey"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bbd22239fafefc42138ca5da064f3c17726a80d2379d817a3521240e78dd0064"
+dependencies = [
+ "smallvec",
+ "str_indices",
+]
+
 [[package]]
 name = "ruff"
-version = "0.0.99"
+version = "0.0.107"
 dependencies = [
  "anyhow",
  "assert_cmd",
@@ -2220,7 +2230,6 @@ dependencies = [
  "chrono",
  "clap 4.0.15",
  "clearscreen",
- "codegen",
  "colored",
  "common-path",
  "criterion",
@@ -2239,6 +2248,7 @@ dependencies = [
  "path-absolutize",
  "rayon",
  "regex",
+ "ropey",
  "rustpython-ast",
  "rustpython-common",
  "rustpython-parser",
@@ -2254,6 +2264,22 @@ dependencies = [
  "walkdir",
 ]
 
+[[package]]
+name = "ruff_dev"
+version = "0.0.107"
+dependencies = [
+ "anyhow",
+ "clap 4.0.15",
+ "codegen",
+ "itertools",
+ "ruff",
+ "rustpython-ast",
+ "rustpython-common",
+ "rustpython-parser",
+ "strum",
+ "strum_macros",
+]
+
 [[package]]
 name = "rustls"
 version = "0.20.6"
@@ -2559,6 +2585,12 @@ version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"
 
+[[package]]
+name = "str_indices"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9d9199fa80c817e074620be84374a520062ebac833f358d74b37060ce4a0f2c0"
+
 [[package]]
 name = "string_cache"
 version = "0.8.4"

Cargo.toml

@@ -1,11 +1,12 @@
 [workspace]
 members = [
-    "flake8_to_ruff",
+  "flake8_to_ruff",
+  "ruff_dev",
 ]
 
 [package]
 name = "ruff"
-version = "0.0.99"
+version = "0.0.107"
 edition = "2021"
 
 [lib]
@@ -31,6 +32,7 @@ once_cell = { version = "1.13.1" }
 path-absolutize = { version = "3.0.14", features = ["once_cell_cache", "use_unix_paths_on_wasm"] }
 rayon = { version = "1.5.3" }
 regex = { version = "1.6.0" }
+ropey = { version = "1.5.0" }
 rustpython-ast = { features = ["unparse"], git = "https://github.com/RustPython/RustPython.git", rev = "77b821a1941019fe34f73ce17cea013ae1b98fd0" }
 rustpython-common = { git = "https://github.com/RustPython/RustPython.git", rev = "77b821a1941019fe34f73ce17cea013ae1b98fd0" }
 rustpython-parser = { features = ["lalrpop"], git = "https://github.com/RustPython/RustPython.git", rev = "77b821a1941019fe34f73ce17cea013ae1b98fd0" }
@@ -55,7 +57,6 @@ getrandom = { version = "0.2.7", features = ["js"] }
 
 [dev-dependencies]
 assert_cmd = { version = "2.0.4" }
-codegen = { version = "0.2.0" }
 criterion = { version = "0.4.0" }
 insta = { version = "1.19.1", features = ["yaml"] }
 test-case = { version = "2.2.2" }

README.md

@@ -15,15 +15,15 @@ An extremely fast Python linter, written in Rust.
   <i>Linting the CPython codebase from scratch.</i>
 </p>
 
-- ⚡️ 10-100x faster than existing linters
-- 🐍 Installable via `pip`
-- 🤝 Python 3.10 compatibility
-- 🛠️ `pyproject.toml` support
-- 📦 [ESLint](https://eslint.org/docs/latest/user-guide/command-line-interface#caching)-inspired cache support
-- 🔧 [ESLint](https://eslint.org/docs/latest/user-guide/command-line-interface#--fix)-inspired autofix support (e.g., automatically remove unused imports)
-- 👀 [TypeScript](https://www.typescriptlang.org/docs/handbook/configuring-watch.html)-inspired `--watch` support, for continuous file monitoring
-- ⚖️ [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/))
+- ⚡️  10-100x faster than existing linters
+- 🐍  Installable via `pip`
+- 🤝  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
+- ⚖️  [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/))
 
 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
@@ -31,6 +31,13 @@ of plugins), [`pydocstyle`](https://pypi.org/project/pydocstyle/), [`yesqa`](htt
 and even a subset of [`pyupgrade`](https://pypi.org/project/pyupgrade/) and [`autoflake`](https://pypi.org/project/autoflake/)
 all while executing tens or hundreds of times faster than any individual tool.
 
+(Coming from Flake8? Try [`flake8-to-ruff`](https://pypi.org/project/flake8-to-ruff/) to
+automatically convert your existing configuration.)
+
+Ruff is actively developed and used in major open-source projects
+like [Zulip](https://github.com/zulip/zulip), [pydantic](https://github.com/pydantic/pydantic),
+and [Saleor](https://github.com/saleor/saleor).
+
 Read the [launch blog post](https://notes.crmarsh.com/python-tooling-could-be-much-much-faster).
 
 ## Table of Contents
@@ -39,17 +46,18 @@ Read the [launch blog post](https://notes.crmarsh.com/python-tooling-could-be-mu
 2. [Configuration](#configuration)
 3. [Supported Rules](#supported-rules)
    1. [Pyflakes](#pyflakes)
-   2. [pycodestyle (error)](#pycodestyle-error)
-   3. [pycodestyle (warning)](#pycodestyle-warning)
-   4. [pydocstyle](#pydocstyle)
-   5. [pyupgrade](#pyupgrade)
-   6. [pep8-naming](#pep8-naming)
-   7. [flake8-comprehensions](#flake8-comprehensions)
-   8. [flake8-bugbear](#flake8-bugbear)
-   9. [flake8-builtins](#flake8-builtins)
-   10. [flake8-print](#flake8-print)
-   11. [flake8-quotes](#flake8-quotes)
-   12. [Meta rules](#meta-rules)
+   2. [pycodestyle](#pycodestyle)
+   3. [pydocstyle](#pydocstyle)
+   4. [pyupgrade](#pyupgrade)
+   5. [pep8-naming](#pep8-naming)
+   6. [flake8-comprehensions](#flake8-comprehensions)
+   7. [flake8-bugbear](#flake8-bugbear)
+   8. [flake8-builtins](#flake8-builtins)
+   9. [flake8-print](#flake8-print)
+   10. [flake8-quotes](#flake8-quotes)
+   11. [flake8-annotations](#flake8-annotations)
+   12. [Ruff-specific rules](#ruff-specific-rules)
+   13. [Meta rules](#meta-rules)
 5. [Editor Integrations](#editor-integrations)
 6. [FAQ](#faq)
 7. [Development](#development)
@@ -89,7 +97,7 @@ Ruff also works with [pre-commit](https://pre-commit.com):
 ```yaml
 repos:
   - repo: https://github.com/charliermarsh/ruff-pre-commit
-    rev: v0.0.99
+    rev: v0.0.107
     hooks:
       - id: ruff
 ```
@@ -195,7 +203,7 @@ Options:
           Exit with status code "0", even upon detecting errors
   -w, --watch
           Run in watch mode by re-running whenever files change
-  -f, --fix
+      --fix
           Attempt to automatically fix lint errors
   -n, --no-cache
           Disable cache reads
@@ -290,12 +298,19 @@ add `noqa` directives to all failing lines, with the appropriate error codes.**
 
 ## Supported Rules
 
+Regardless of the rule's origin, Ruff re-implements every rule in Rust as a first-party feature.
+
 By default, Ruff enables all `E` and `F` error codes, which correspond to those built-in to Flake8.
 
 The 🛠 emoji indicates that a rule is automatically fixable by the `--fix` command-line option.
 
+<!-- Sections automatically generated by `cargo dev generate-rules-table`. -->
+<!-- Begin auto-generated sections. -->
+
 ### Pyflakes
 
+For more, see [Pyflakes](https://pypi.org/project/pyflakes/2.5.0/) on PyPI.
+
 | Code | Name | Message | Fix |
 | ---- | ---- | ------- | --- |
 | F401 | UnusedImport | `...` imported but unused | 🛠 |
@@ -311,7 +326,7 @@ The 🛠 emoji indicates that a rule is automatically fixable by the `--fix` com
 | F621 | ExpressionsInStarAssignment | Too many expressions in star-unpacking assignment |  |
 | F622 | TwoStarredExpressions | Two starred expressions in assignment |  |
 | F631 | AssertTuple | Assert test is a non-empty tuple, which is always `True` |  |
-| F632 | IsLiteral | Use `==` and `!=` to compare constant literals |  |
+| F632 | IsLiteral | Use `==` and `!=` to compare constant literals | 🛠 |
 | F633 | InvalidPrintSyntax | Use of `>>` is invalid with `print` function |  |
 | F634 | IfTuple | If test is a tuple, which is always `True` |  |
 | F701 | BreakOutsideLoop | `break` outside loop |  |
@@ -325,9 +340,11 @@ The 🛠 emoji indicates that a rule is automatically fixable by the `--fix` com
 | F823 | UndefinedLocal | Local variable `...` referenced before assignment |  |
 | F831 | DuplicateArgumentName | Duplicate argument name in function definition |  |
 | F841 | UnusedVariable | Local variable `...` is assigned to but never used |  |
-| F901 | RaiseNotImplemented | `raise NotImplemented` should be `raise NotImplementedError` |  |
+| F901 | RaiseNotImplemented | `raise NotImplemented` should be `raise NotImplementedError` | 🛠 |
 
-### pycodestyle (error)
+### pycodestyle
+
+For more, see [pycodestyle](https://pypi.org/project/pycodestyle/2.9.1/) on PyPI.
 
 | Code | Name | Message | Fix |
 | ---- | ---- | ------- | --- |
@@ -345,16 +362,13 @@ The 🛠 emoji indicates that a rule is automatically fixable by the `--fix` com
 | E743 | AmbiguousFunctionName | Ambiguous function name: `...` |  |
 | E902 | IOError | IOError: `...` |  |
 | E999 | SyntaxError | SyntaxError: `...` |  |
-
-### pycodestyle (warning)
-
-| Code | Name | Message | Fix |
-| ---- | ---- | ------- | --- |
 | W292 | NoNewLineAtEndOfFile | No newline at end of file |  |
 | W605 | InvalidEscapeSequence | Invalid escape sequence: '\c' |  |
 
 ### pydocstyle
 
+For more, see [pydocstyle](https://pypi.org/project/pydocstyle/6.1.1/) on PyPI.
+
 | Code | Name | Message | Fix |
 | ---- | ---- | ------- | --- |
 | D100 | PublicModule | Missing docstring in public module |  |
@@ -404,6 +418,8 @@ The 🛠 emoji indicates that a rule is automatically fixable by the `--fix` com
 
 ### pyupgrade
 
+For more, see [pyupgrade](https://pypi.org/project/pyupgrade/3.2.0/) on PyPI.
+
 | Code | Name | Message | Fix |
 | ---- | ---- | ------- | --- |
 | U001 | UselessMetaclassType | `__metaclass__ = type` is implied | 🛠 |
@@ -414,9 +430,12 @@ The 🛠 emoji indicates that a rule is automatically fixable by the `--fix` com
 | U006 | UsePEP585Annotation | Use `list` instead of `List` for type annotations | 🛠 |
 | U007 | UsePEP604Annotation | Use `X \| Y` for type annotations | 🛠 |
 | U008 | SuperCallWithParameters | Use `super()` instead of `super(__class__, self)` | 🛠 |
+| U009 | PEP3120UnnecessaryCodingComment | utf-8 encoding declaration is unnecessary | 🛠 |
 
 ### pep8-naming
 
+For more, see [pep8-naming](https://pypi.org/project/pep8-naming/0.13.2/) on PyPI.
+
 | Code | Name | Message | Fix |
 | ---- | ---- | ------- | --- |
 | N801 | InvalidClassName | Class name `...` should use CapWords convention  |  |
@@ -437,6 +456,8 @@ The 🛠 emoji indicates that a rule is automatically fixable by the `--fix` com
 
 ### flake8-comprehensions
 
+For more, see [flake8-comprehensions](https://pypi.org/project/flake8-comprehensions/3.10.1/) on PyPI.
+
 | Code | Name | Message | Fix |
 | ---- | ---- | ------- | --- |
 | C400 | UnnecessaryGeneratorList | Unnecessary generator (rewrite as a `list` comprehension) | 🛠 |
@@ -458,19 +479,30 @@ The 🛠 emoji indicates that a rule is automatically fixable by the `--fix` com
 
 ### flake8-bugbear
 
+For more, see [flake8-bugbear](https://pypi.org/project/flake8-bugbear/22.10.27/) on PyPI.
+
 | Code | Name | Message | Fix |
 | ---- | ---- | ------- | --- |
 | B002 | UnaryPrefixIncrement | Python does not support the unary prefix increment. |  |
+| B003 | AssignmentToOsEnviron | Assigning to `os.environ` doesn't clear the environment. |  |
+| B004 | UnreliableCallableCheck |  Using `hasattr(x, '__call__')` to test if x is callable is unreliable. Use `callable(x)` for consistent results. |  |
+| B005 | StripWithMultiCharacters | Using `.strip()` with multi-character strings is misleading the reader. |  |
 | B006 | MutableArgumentDefault | Do not use mutable data structures for argument defaults. |  |
 | B007 | UnusedLoopControlVariable | Loop control variable `i` not used within the loop body. | 🛠 |
+| B008 | FunctionCallArgumentDefault | Do not perform function calls in argument defaults. |  |
 | B011 | DoNotAssertFalse | Do not `assert False` (`python -O` removes these calls), raise `AssertionError()` | 🛠 |
 | B013 | RedundantTupleInExceptionHandler | A length-one tuple literal is redundant. Write `except ValueError:` instead of `except (ValueError,):`. |  |
 | B014 | DuplicateHandlerException | Exception handler with duplicate exception: `ValueError` | 🛠 |
+| B015 | UselessComparison | Pointless comparison. This comparison does nothing but waste CPU instructions. Either prepend `assert` or remove it. |  |
+| B016 | CannotRaiseLiteral | Cannot raise a literal. Did you intend to return it or raise an Exception? |  |
 | B017 | NoAssertRaisesException | `assertRaises(Exception):` should be considered evil. |  |
+| B018 | UselessExpression | Found useless expression. Either assign it to a variable or remove it. |  |
 | B025 | DuplicateTryBlockException | try-except block with duplicate exception `Exception` |  |
 
 ### flake8-builtins
 
+For more, see [flake8-builtins](https://pypi.org/project/flake8-builtins/2.0.1/) on PyPI.
+
 | Code | Name | Message | Fix |
 | ---- | ---- | ------- | --- |
 | A001 | BuiltinVariableShadowing | Variable `...` is shadowing a python builtin |  |
@@ -479,6 +511,8 @@ The 🛠 emoji indicates that a rule is automatically fixable by the `--fix` com
 
 ### flake8-print
 
+For more, see [flake8-print](https://pypi.org/project/flake8-print/5.0.0/) on PyPI.
+
 | Code | Name | Message | Fix |
 | ---- | ---- | ------- | --- |
 | T201 | PrintFound | `print` found | 🛠 |
@@ -486,6 +520,8 @@ The 🛠 emoji indicates that a rule is automatically fixable by the `--fix` com
 
 ### flake8-quotes
 
+For more, see [flake8-quotes](https://pypi.org/project/flake8-quotes/3.3.1/) on PyPI.
+
 | Code | Name | Message | Fix |
 | ---- | ---- | ------- | --- |
 | Q000 | BadQuotesInlineString | Single quotes found but double quotes preferred |  |
@@ -493,12 +529,38 @@ The 🛠 emoji indicates that a rule is automatically fixable by the `--fix` com
 | Q002 | BadQuotesDocstring | Single quote docstring found but double quotes preferred |  |
 | Q003 | AvoidQuoteEscape | Change outer quotes to avoid escaping inner quotes |  |
 
+### flake8-annotations
+
+For more, see [flake8-annotations](https://pypi.org/project/flake8-annotations/2.9.1/) on PyPI.
+
+| Code | Name | Message | Fix |
+| ---- | ---- | ------- | --- |
+| ANN001 | MissingTypeFunctionArgument | Missing type annotation for function argument `...` |  |
+| ANN002 | MissingTypeArgs | Missing type annotation for `*...` |  |
+| ANN003 | MissingTypeKwargs | Missing type annotation for `**...` |  |
+| ANN101 | MissingTypeSelf | Missing type annotation for `...` in method |  |
+| ANN102 | MissingTypeCls | Missing type annotation for `...` in classmethod |  |
+| ANN201 | MissingReturnTypePublicFunction | Missing return type annotation for public function `...` |  |
+| ANN202 | MissingReturnTypePrivateFunction | Missing return type annotation for private function `...` |  |
+| ANN204 | MissingReturnTypeMagicMethod | Missing return type annotation for magic method `...` |  |
+| ANN205 | MissingReturnTypeStaticMethod | Missing return type annotation for staticmethod `...` |  |
+| ANN206 | MissingReturnTypeClassMethod | Missing return type annotation for classmethod `...` |  |
+
+### Ruff-specific rules
+
+| Code | Name | Message | Fix |
+| ---- | ---- | ------- | --- |
+| RUF001 | AmbiguousUnicodeCharacterString | String contains ambiguous unicode character '𝐁' (did you mean 'B'?) | 🛠 |
+| RUF002 | AmbiguousUnicodeCharacterDocstring | Docstring contains ambiguous unicode character '𝐁' (did you mean 'B'?) | 🛠 |
+
 ### Meta rules
 
 | Code | Name | Message | Fix |
 | ---- | ---- | ------- | --- |
 | M001 | UnusedNOQA | Unused `noqa` directive | 🛠 |
 
+<!-- End auto-generated sections. -->
+
 ## Editor Integrations
 
 ### PyCharm
@@ -549,6 +611,9 @@ stylistic lint rules that are obviated by autoformatting.
 
 ### How does Ruff compare to Flake8?
 
+(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.
 
@@ -566,9 +631,10 @@ including:
 - [`flake8-super`](https://pypi.org/project/flake8-super/)
 - [`flake8-print`](https://pypi.org/project/flake8-print/)
 - [`flake8-quotes`](https://pypi.org/project/flake8-quotes/)
+- [`flake8-annotations`](https://pypi.org/project/flake8-annotations/)
 - [`flake8-comprehensions`](https://pypi.org/project/flake8-comprehensions/)
-- [`flake8-bugbear`](https://pypi.org/project/flake8-bugbear/) (10/32)
-- [`pyupgrade`](https://pypi.org/project/pyupgrade/) (10/34)
+- [`flake8-bugbear`](https://pypi.org/project/flake8-bugbear/) (17/32)
+- [`pyupgrade`](https://pypi.org/project/pyupgrade/) (11/34)
 - [`autoflake`](https://pypi.org/project/autoflake/) (1/7)
 
 Beyond rule-set parity, Ruff suffers from the following limitations vis-à-vis Flake8:
@@ -588,11 +654,12 @@ Today, Ruff can be used to replace Flake8 when used with any of the following pl
 - [`flake8-super`](https://pypi.org/project/flake8-super/)
 - [`flake8-print`](https://pypi.org/project/flake8-print/)
 - [`flake8-quotes`](https://pypi.org/project/flake8-quotes/)
+- [`flake8-annotations`](https://pypi.org/project/flake8-annotations/)
 - [`flake8-comprehensions`](https://pypi.org/project/flake8-comprehensions/)
-- [`flake8-bugbear`](https://pypi.org/project/flake8-bugbear/) (10/32)
+- [`flake8-bugbear`](https://pypi.org/project/flake8-bugbear/) (17/32)
 
 Ruff also implements the functionality that you get from [`yesqa`](https://github.com/asottile/yesqa),
-and a subset of the rules implemented in [`pyupgrade`](https://pypi.org/project/pyupgrade/) (10/34).
+and a subset of the rules implemented in [`pyupgrade`](https://pypi.org/project/pyupgrade/) (11/34).
 
 If you're looking to use Ruff, but rely on an unsupported Flake8 plugin, free to file an Issue.
 
@@ -684,7 +751,7 @@ extend-ignore = [
 
 ## Development
 
-Ruff is written in Rust (1.64.0). You'll need to install the [Rust toolchain](https://www.rust-lang.org/tools/install)
+Ruff is written in Rust (1.65.0). You'll need to install the [Rust toolchain](https://www.rust-lang.org/tools/install)
 for development.
 
 Assuming you have `cargo` installed, you can run:

benches/source_code_locator.rs

@@ -1,13 +1,16 @@
 use std::path::Path;
 
 use criterion::{black_box, criterion_group, criterion_main, Criterion};
+use ropey::Rope;
 use ruff::fs;
-use ruff::source_code_locator::compute_offsets;
 
 fn criterion_benchmark(c: &mut Criterion) {
     let contents = fs::read_file(Path::new("resources/test/fixtures/D.py")).unwrap();
-    c.bench_function("compute_offsets", |b| {
-        b.iter(|| compute_offsets(black_box(&contents)))
+    c.bench_function("rope", |b| {
+        b.iter(|| {
+            let rope = Rope::from_str(black_box(&contents));
+            rope.line_to_char(black_box(4));
+        })
     });
 }
 

examples/generate_rules_table.rs

@@ -1,28 +0,0 @@
-//! Generate a Markdown-compatible table of supported lint rules.
-
-use ruff::checks::{CheckCategory, CheckCode};
-use strum::IntoEnumIterator;
-
-fn main() {
-    for check_category in CheckCategory::iter() {
-        println!("### {}", check_category.title());
-        println!();
-
-        println!("| Code | Name | Message | Fix |");
-        println!("| ---- | ---- | ------- | --- |");
-        for check_code in CheckCode::iter() {
-            if check_code.category() == check_category {
-                let check_kind = check_code.kind();
-                let fix_token = if check_kind.fixable() { "🛠" } else { "" };
-                println!(
-                    "| {} | {} | {} | {} |",
-                    check_kind.code().as_ref(),
-                    check_kind.as_ref(),
-                    check_kind.summary().replace("|", r"\|"),
-                    fix_token
-                );
-            }
-        }
-        println!();
-    }
-}

flake8_to_ruff/Cargo.lock

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

flake8_to_ruff/Cargo.toml

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

flake8_to_ruff/README.md

@@ -17,7 +17,7 @@ pip install flake8-to-ruff
 
 ### Usage
 
-To run Ruff, try any of the following:
+To run `flake8-to-ruff`:
 
 ```shell
 flake8-to-ruff path/to/setup.cfg
@@ -25,6 +25,60 @@ flake8-to-ruff path/to/tox.ini
 flake8-to-ruff path/to/.flake8
 ```
 
+`flake8-to-ruff` will print the relevant `pyproject.toml` sections to standard output, like so:
+
+```toml
+[tool.ruff]
+exclude = [
+    '.svn',
+    'CVS',
+    '.bzr',
+    '.hg',
+    '.git',
+    '__pycache__',
+    '.tox',
+    '.idea',
+    '.mypy_cache',
+    '.venv',
+    'node_modules',
+    '_state_machine.py',
+    'test_fstring.py',
+    'bad_coding2.py',
+    'badsyntax_*.py',
+]
+select = [
+    'A',
+    'E',
+    'F',
+    'Q',
+]
+ignore = []
+
+[tool.ruff.flake8-quotes]
+inline-quotes = 'single'
+
+[tool.ruff.pep8-naming]
+ignore-names = [
+    'foo',
+    'bar',
+]
+```
+
+### Plugins
+
+`flake8-to-ruff` will attempt to infer any activated plugins based on the settings provided in your
+configuration file.
+
+For example, if your `.flake8` file includes a `docstring-convention` property, `flake8-to-ruff`
+will enable the appropriate [`flake8-docstrings`](https://pypi.org/project/flake8-docstrings/)
+checks.
+
+Alternatively, you can manually specify plugins on the command-line:
+
+```shell
+flake8-to-ruff path/to/.flake8 --plugin flake8-builtins --plugin flake8-quotes
+```
+
 ## Limitations
 
 1. Ruff only supports a subset of the Flake configuration options. `flake8-to-ruff` will warn on and
@@ -33,9 +87,6 @@ flake8-to-ruff path/to/.flake8
 2. Ruff will omit any error codes that are unimplemented or unsupported by Ruff, including error
    codes from unsupported plugins. (See the [Ruff README](https://github.com/charliermarsh/ruff#user-content-how-does-ruff-compare-to-flake8)
    for the complete list of supported plugins.)
-3. `flake8-to-ruff` does not auto-detect your Flake8 plugins, so any reliance on Flake8 plugins that
-   implicitly enable third-party checks will be ignored. Instead, add those error codes to your
-   `select` or `extend-select` fields, so that `flake8-to-ruff` can pick them up.
 
 ## License
 

flake8_to_ruff/examples/poetry.ini

@@ -0,0 +1,36 @@
+[flake8]
+min_python_version = 3.7.0
+max-line-length = 88
+ban-relative-imports = true
+# flake8-use-fstring: https://github.com/MichaelKim0407/flake8-use-fstring#--percent-greedy-and---format-greedy
+format-greedy = 1
+inline-quotes = double
+enable-extensions = TC, TC1
+type-checking-strict = true
+eradicate-whitelist-extend = ^-.*;
+extend-ignore =
+    # E203: Whitespace before ':' (pycqa/pycodestyle#373)
+    E203,
+    # SIM106: Handle error-cases first
+    SIM106,
+    # ANN101: Missing type annotation for self in method
+    ANN101,
+    # ANN102: Missing type annotation for cls in classmethod
+    ANN102,
+    # PIE781: assign-and-return
+    PIE781,
+    # PIE798 no-unnecessary-class: Consider using a module for namespacing instead
+    PIE798,
+per-file-ignores =
+    # TC002: Move third-party import '...' into a type-checking block
+    __init__.py:TC002,
+    # ANN201: Missing return type annotation for public function
+    tests/test_*:ANN201
+    tests/**/test_*:ANN201
+extend-exclude =
+    # Frozen and not subject to change in this repo:
+    get-poetry.py,
+    install-poetry.py,
+    # External to the project's coding standards:
+    tests/fixtures/*,
+    tests/**/fixtures/*,

flake8_to_ruff/examples/python-discord.ini

@@ -0,0 +1,19 @@
+[flake8]
+max-line-length=120
+docstring-convention=all
+import-order-style=pycharm
+application_import_names=bot,tests
+exclude=.cache,.venv,.git,constants.py
+extend-ignore=
+    B311,W503,E226,S311,T000,E731
+    # Missing Docstrings
+    D100,D104,D105,D107,
+    # Docstring Whitespace
+    D203,D212,D214,D215,
+    # Docstring Quotes
+    D301,D302,
+    # Docstring Content
+    D400,D401,D402,D404,D405,D406,D407,D408,D409,D410,D411,D412,D413,D414,D416,D417
+    # Type Annotations
+    ANN002,ANN003,ANN101,ANN102,ANN204,ANN206,ANN401
+per-file-ignores=tests/*:D,ANN

flake8_to_ruff/examples/requests.ini

@@ -0,0 +1,6 @@
+[flake8]
+ignore = E203, E501, W503
+per-file-ignores =
+    requests/__init__.py:E402, F401
+    requests/compat.py:E402, F401
+    tests/compat.py:F401

flake8_to_ruff/src/converter.rs

@@ -1,21 +1,74 @@
-use std::collections::HashMap;
+use std::collections::{BTreeSet, HashMap};
 
 use anyhow::Result;
+use ruff::checks_gen::CheckCodePrefix;
 use ruff::flake8_quotes::settings::Quote;
 use ruff::settings::options::Options;
 use ruff::settings::pyproject::Pyproject;
-use ruff::{flake8_quotes, pep8_naming};
+use ruff::{flake8_annotations, flake8_quotes, pep8_naming};
 
-use crate::parser;
+use crate::plugin::Plugin;
+use crate::{parser, plugin};
 
-pub fn convert(config: HashMap<String, HashMap<String, Option<String>>>) -> Result<Pyproject> {
-    // Extract the Flake8 section.
-    let flake8 = config
-        .get("flake8")
-        .expect("Unable to find flake8 section in INI file.");
+pub fn convert(
+    flake8: &HashMap<String, Option<String>>,
+    plugins: Option<Vec<Plugin>>,
+) -> Result<Pyproject> {
+    // Extract all referenced check code prefixes, to power plugin inference.
+    let mut referenced_codes: BTreeSet<CheckCodePrefix> = Default::default();
+    for (key, value) in flake8 {
+        if let Some(value) = value {
+            match key.as_str() {
+                "select" | "ignore" | "extend-select" | "extend_select" | "extend-ignore"
+                | "extend_ignore" => {
+                    referenced_codes.extend(parser::parse_prefix_codes(value.as_ref()));
+                }
+                "per-file-ignores" | "per_file_ignores" => {
+                    if let Ok(per_file_ignores) =
+                        parser::parse_files_to_codes_mapping(value.as_ref())
+                    {
+                        for (_, codes) in parser::collect_per_file_ignores(per_file_ignores) {
+                            referenced_codes.extend(codes);
+                        }
+                    }
+                }
+                _ => {}
+            }
+        }
+    }
+
+    // Check if the user has specified a `select`. If not, we'll add our own
+    // default `select`, and populate it based on user plugins.
+    let mut select = flake8
+        .get("select")
+        .and_then(|value| {
+            value
+                .as_ref()
+                .map(|value| BTreeSet::from_iter(parser::parse_prefix_codes(value)))
+        })
+        .unwrap_or_else(|| {
+            plugin::resolve_select(
+                flake8,
+                &plugins.unwrap_or_else(|| {
+                    plugin::infer_plugins_from_options(flake8)
+                        .into_iter()
+                        .chain(plugin::infer_plugins_from_codes(&referenced_codes))
+                        .collect()
+                }),
+            )
+        });
+    let mut ignore = flake8
+        .get("ignore")
+        .and_then(|value| {
+            value
+                .as_ref()
+                .map(|value| BTreeSet::from_iter(parser::parse_prefix_codes(value)))
+        })
+        .unwrap_or_default();
 
     // Parse each supported option.
     let mut options: Options = Default::default();
+    let mut flake8_annotations: flake8_annotations::settings::Options = Default::default();
     let mut flake8_quotes: flake8_quotes::settings::Options = Default::default();
     let mut pep8_naming: pep8_naming::settings::Options = Default::default();
     for (key, value) in flake8 {
@@ -27,16 +80,19 @@ pub fn convert(config: HashMap<String, HashMap<String, Option<String>>>) -> Resu
                     Err(e) => eprintln!("Unable to parse '{key}' property: {e}"),
                 },
                 "select" => {
-                    options.select = Some(parser::parse_prefix_codes(value.as_ref()));
-                }
-                "extend-select" | "extend_select" => {
-                    options.extend_select = Some(parser::parse_prefix_codes(value.as_ref()));
+                    // No-op (handled above).
+                    select.extend(parser::parse_prefix_codes(value.as_ref()));
                 }
                 "ignore" => {
-                    options.ignore = Some(parser::parse_prefix_codes(value.as_ref()));
+                    // No-op (handled above).
+                }
+                "extend-select" | "extend_select" => {
+                    // Unlike Flake8, use a single explicit `select`.
+                    select.extend(parser::parse_prefix_codes(value.as_ref()));
                 }
                 "extend-ignore" | "extend_ignore" => {
-                    options.extend_ignore = Some(parser::parse_prefix_codes(value.as_ref()));
+                    // Unlike Flake8, use a single explicit `ignore`.
+                    ignore.extend(parser::parse_prefix_codes(value.as_ref()));
                 }
                 "exclude" => {
                     options.exclude = Some(parser::parse_strings(value.as_ref()));
@@ -53,6 +109,25 @@ pub fn convert(config: HashMap<String, HashMap<String, Option<String>>>) -> Resu
                         Err(e) => eprintln!("Unable to parse '{key}' property: {e}"),
                     }
                 }
+                // flake8-annotations
+                "suppress-none-returning" | "suppress_none_returning" => {
+                    match parser::parse_bool(value.as_ref()) {
+                        Ok(bool) => flake8_annotations.suppress_none_returning = Some(bool),
+                        Err(e) => eprintln!("Unable to parse '{key}' property: {e}"),
+                    }
+                }
+                "suppress-dummy-args" | "suppress_dummy_args" => {
+                    match parser::parse_bool(value.as_ref()) {
+                        Ok(bool) => flake8_annotations.suppress_dummy_args = Some(bool),
+                        Err(e) => eprintln!("Unable to parse '{key}' property: {e}"),
+                    }
+                }
+                "mypy-init-return" | "mypy_init_return" => {
+                    match parser::parse_bool(value.as_ref()) {
+                        Ok(bool) => flake8_annotations.mypy_init_return = Some(bool),
+                        Err(e) => eprintln!("Unable to parse '{key}' property: {e}"),
+                    }
+                }
                 // flake8-quotes
                 "quotes" | "inline-quotes" | "inline_quotes" => match value.trim() {
                     "'" | "single" => flake8_quotes.inline_quotes = Some(Quote::Single),
@@ -69,10 +144,9 @@ pub fn convert(config: HashMap<String, HashMap<String, Option<String>>>) -> Resu
                     "\"" | "double" => flake8_quotes.docstring_quotes = Some(Quote::Single),
                     _ => eprintln!("Unexpected '{key}' value: {value}"),
                 },
-                "avoid-escape" | "avoid_escape" => match value.trim() {
-                    "true" => flake8_quotes.avoid_escape = Some(true),
-                    "false" => flake8_quotes.avoid_escape = Some(false),
-                    _ => eprintln!("Unexpected '{key}' value: {value}"),
+                "avoid-escape" | "avoid_escape" => match parser::parse_bool(value.as_ref()) {
+                    Ok(bool) => flake8_quotes.avoid_escape = Some(bool),
+                    Err(e) => eprintln!("Unable to parse '{key}' property: {e}"),
                 },
                 // pep8-naming
                 "ignore-names" | "ignore_names" => {
@@ -86,12 +160,19 @@ pub fn convert(config: HashMap<String, HashMap<String, Option<String>>>) -> Resu
                     pep8_naming.staticmethod_decorators =
                         Some(parser::parse_strings(value.as_ref()));
                 }
+                // flake8-docstrings
+                "docstring-convention" => {
+                    // No-op (handled above).
+                }
                 // Unknown
                 _ => eprintln!("Skipping unsupported property: {key}"),
             }
         }
     }
 
+    // Deduplicate and sort.
+    options.select = Some(Vec::from_iter(select));
+    options.ignore = Some(Vec::from_iter(ignore));
     if flake8_quotes != Default::default() {
         options.flake8_quotes = Some(flake8_quotes);
     }
@@ -108,26 +189,34 @@ mod tests {
     use std::collections::HashMap;
 
     use anyhow::Result;
+    use ruff::checks_gen::CheckCodePrefix;
     use ruff::flake8_quotes;
     use ruff::settings::options::Options;
     use ruff::settings::pyproject::Pyproject;
 
     use crate::converter::convert;
+    use crate::plugin::Plugin;
 
     #[test]
     fn it_converts_empty() -> Result<()> {
-        let actual = convert(HashMap::from([("flake8".to_string(), HashMap::from([]))]))?;
+        let actual = convert(&HashMap::from([]), None)?;
         let expected = Pyproject::new(Options {
             line_length: None,
+            fix: None,
             exclude: None,
             extend_exclude: None,
-            select: None,
+            select: Some(vec![
+                CheckCodePrefix::E,
+                CheckCodePrefix::F,
+                CheckCodePrefix::W,
+            ]),
             extend_select: None,
-            ignore: None,
+            ignore: Some(vec![]),
             extend_ignore: None,
             per_file_ignores: None,
             dummy_variable_rgx: None,
             target_version: None,
+            flake8_annotations: None,
             flake8_quotes: None,
             pep8_naming: None,
         });
@@ -138,21 +227,27 @@ mod tests {
 
     #[test]
     fn it_converts_dashes() -> Result<()> {
-        let actual = convert(HashMap::from([(
-            "flake8".to_string(),
-            HashMap::from([("max-line-length".to_string(), Some("100".to_string()))]),
-        )]))?;
+        let actual = convert(
+            &HashMap::from([("max-line-length".to_string(), Some("100".to_string()))]),
+            Some(vec![]),
+        )?;
         let expected = Pyproject::new(Options {
             line_length: Some(100),
+            fix: None,
             exclude: None,
             extend_exclude: None,
-            select: None,
+            select: Some(vec![
+                CheckCodePrefix::E,
+                CheckCodePrefix::F,
+                CheckCodePrefix::W,
+            ]),
             extend_select: None,
-            ignore: None,
+            ignore: Some(vec![]),
             extend_ignore: None,
             per_file_ignores: None,
             dummy_variable_rgx: None,
             target_version: None,
+            flake8_annotations: None,
             flake8_quotes: None,
             pep8_naming: None,
         });
@@ -163,21 +258,27 @@ mod tests {
 
     #[test]
     fn it_converts_underscores() -> Result<()> {
-        let actual = convert(HashMap::from([(
-            "flake8".to_string(),
-            HashMap::from([("max_line_length".to_string(), Some("100".to_string()))]),
-        )]))?;
+        let actual = convert(
+            &HashMap::from([("max_line_length".to_string(), Some("100".to_string()))]),
+            Some(vec![]),
+        )?;
         let expected = Pyproject::new(Options {
             line_length: Some(100),
+            fix: None,
             exclude: None,
             extend_exclude: None,
-            select: None,
+            select: Some(vec![
+                CheckCodePrefix::E,
+                CheckCodePrefix::F,
+                CheckCodePrefix::W,
+            ]),
             extend_select: None,
-            ignore: None,
+            ignore: Some(vec![]),
             extend_ignore: None,
             per_file_ignores: None,
             dummy_variable_rgx: None,
             target_version: None,
+            flake8_annotations: None,
             flake8_quotes: None,
             pep8_naming: None,
         });
@@ -188,21 +289,27 @@ mod tests {
 
     #[test]
     fn it_ignores_parse_errors() -> Result<()> {
-        let actual = convert(HashMap::from([(
-            "flake8".to_string(),
-            HashMap::from([("max_line_length".to_string(), Some("abc".to_string()))]),
-        )]))?;
+        let actual = convert(
+            &HashMap::from([("max_line_length".to_string(), Some("abc".to_string()))]),
+            Some(vec![]),
+        )?;
         let expected = Pyproject::new(Options {
             line_length: None,
+            fix: None,
             exclude: None,
             extend_exclude: None,
-            select: None,
+            select: Some(vec![
+                CheckCodePrefix::E,
+                CheckCodePrefix::F,
+                CheckCodePrefix::W,
+            ]),
             extend_select: None,
-            ignore: None,
+            ignore: Some(vec![]),
             extend_ignore: None,
             per_file_ignores: None,
             dummy_variable_rgx: None,
             target_version: None,
+            flake8_annotations: None,
             flake8_quotes: None,
             pep8_naming: None,
         });
@@ -212,22 +319,134 @@ mod tests {
     }
 
     #[test]
-    fn it_converts_extensions() -> Result<()> {
-        let actual = convert(HashMap::from([(
-            "flake8".to_string(),
-            HashMap::from([("inline-quotes".to_string(), Some("single".to_string()))]),
-        )]))?;
+    fn it_converts_plugin_options() -> Result<()> {
+        let actual = convert(
+            &HashMap::from([("inline-quotes".to_string(), Some("single".to_string()))]),
+            Some(vec![]),
+        )?;
         let expected = Pyproject::new(Options {
             line_length: None,
+            fix: None,
             exclude: None,
             extend_exclude: None,
-            select: None,
+            select: Some(vec![
+                CheckCodePrefix::E,
+                CheckCodePrefix::F,
+                CheckCodePrefix::W,
+            ]),
             extend_select: None,
-            ignore: None,
+            ignore: Some(vec![]),
             extend_ignore: None,
             per_file_ignores: None,
             dummy_variable_rgx: None,
             target_version: None,
+            flake8_annotations: None,
+            flake8_quotes: Some(flake8_quotes::settings::Options {
+                inline_quotes: Some(flake8_quotes::settings::Quote::Single),
+                multiline_quotes: None,
+                docstring_quotes: None,
+                avoid_escape: None,
+            }),
+            pep8_naming: None,
+        });
+        assert_eq!(actual, expected);
+
+        Ok(())
+    }
+
+    #[test]
+    fn it_converts_docstring_conventions() -> Result<()> {
+        let actual = convert(
+            &HashMap::from([(
+                "docstring-convention".to_string(),
+                Some("numpy".to_string()),
+            )]),
+            Some(vec![Plugin::Flake8Docstrings]),
+        )?;
+        let expected = Pyproject::new(Options {
+            line_length: None,
+            fix: None,
+            exclude: None,
+            extend_exclude: None,
+            select: Some(vec![
+                CheckCodePrefix::D100,
+                CheckCodePrefix::D101,
+                CheckCodePrefix::D102,
+                CheckCodePrefix::D103,
+                CheckCodePrefix::D104,
+                CheckCodePrefix::D105,
+                CheckCodePrefix::D106,
+                CheckCodePrefix::D200,
+                CheckCodePrefix::D201,
+                CheckCodePrefix::D202,
+                CheckCodePrefix::D204,
+                CheckCodePrefix::D205,
+                CheckCodePrefix::D206,
+                CheckCodePrefix::D207,
+                CheckCodePrefix::D208,
+                CheckCodePrefix::D209,
+                CheckCodePrefix::D210,
+                CheckCodePrefix::D211,
+                CheckCodePrefix::D214,
+                CheckCodePrefix::D215,
+                CheckCodePrefix::D300,
+                CheckCodePrefix::D400,
+                CheckCodePrefix::D403,
+                CheckCodePrefix::D404,
+                CheckCodePrefix::D405,
+                CheckCodePrefix::D406,
+                CheckCodePrefix::D407,
+                CheckCodePrefix::D408,
+                CheckCodePrefix::D409,
+                CheckCodePrefix::D410,
+                CheckCodePrefix::D411,
+                CheckCodePrefix::D412,
+                CheckCodePrefix::D414,
+                CheckCodePrefix::D418,
+                CheckCodePrefix::D419,
+                CheckCodePrefix::E,
+                CheckCodePrefix::F,
+                CheckCodePrefix::W,
+            ]),
+            extend_select: None,
+            ignore: Some(vec![]),
+            extend_ignore: None,
+            per_file_ignores: None,
+            dummy_variable_rgx: None,
+            target_version: None,
+            flake8_annotations: None,
+            flake8_quotes: None,
+            pep8_naming: None,
+        });
+        assert_eq!(actual, expected);
+
+        Ok(())
+    }
+
+    #[test]
+    fn it_infers_plugins_if_omitted() -> Result<()> {
+        let actual = convert(
+            &HashMap::from([("inline-quotes".to_string(), Some("single".to_string()))]),
+            None,
+        )?;
+        let expected = Pyproject::new(Options {
+            line_length: None,
+            fix: None,
+            exclude: None,
+            extend_exclude: None,
+            select: Some(vec![
+                CheckCodePrefix::E,
+                CheckCodePrefix::F,
+                CheckCodePrefix::Q,
+                CheckCodePrefix::W,
+            ]),
+            extend_select: None,
+            ignore: Some(vec![]),
+            extend_ignore: None,
+            per_file_ignores: None,
+            dummy_variable_rgx: None,
+            target_version: None,
+            flake8_annotations: None,
             flake8_quotes: Some(flake8_quotes::settings::Options {
                 inline_quotes: Some(flake8_quotes::settings::Quote::Single),
                 multiline_quotes: None,

flake8_to_ruff/src/lib.rs

@@ -2,3 +2,4 @@
 
 pub mod converter;
 mod parser;
+pub mod plugin;

flake8_to_ruff/src/main.rs

@@ -6,6 +6,7 @@ use anyhow::Result;
 use clap::Parser;
 use configparser::ini::Ini;
 use flake8_to_ruff::converter;
+use flake8_to_ruff::plugin::Plugin;
 
 #[derive(Parser)]
 #[command(
@@ -17,6 +18,9 @@ struct Cli {
     /// '.flake8').
     #[arg(required = true)]
     file: PathBuf,
+    /// List of plugins to enable.
+    #[arg(long, value_delimiter = ',')]
+    plugin: Option<Vec<Plugin>>,
 }
 
 fn main() -> Result<()> {
@@ -27,8 +31,13 @@ fn main() -> Result<()> {
     ini.set_multiline(true);
     let config = ini.load(cli.file).map_err(|msg| anyhow::anyhow!(msg))?;
 
+    // Extract the Flake8 section.
+    let flake8 = config
+        .get("flake8")
+        .expect("Unable to find flake8 section in INI file.");
+
     // Create the pyproject.toml.
-    let pyproject = converter::convert(config)?;
+    let pyproject = converter::convert(flake8, cli.plugin)?;
     println!("{}", toml::to_string_pretty(&pyproject)?);
 
     Ok(())

flake8_to_ruff/src/parser.rs

@@ -37,6 +37,15 @@ pub fn parse_strings(value: &str) -> Vec<String> {
         .collect()
 }
 
+/// Parse a boolean.
+pub fn parse_bool(value: &str) -> Result<bool> {
+    match value.trim() {
+        "true" => Ok(true),
+        "false" => Ok(false),
+        _ => Err(anyhow::anyhow!("Unexpected boolean value: {value}")),
+    }
+}
+
 #[derive(Debug)]
 struct Token {
     token_name: TokenType,

flake8_to_ruff/src/plugin.rs

@@ -0,0 +1,396 @@
+use std::collections::{BTreeSet, HashMap};
+use std::str::FromStr;
+
+use anyhow::anyhow;
+use ruff::checks_gen::CheckCodePrefix;
+
+#[derive(Debug, Clone, Ord, PartialOrd, Eq, PartialEq)]
+pub enum Plugin {
+    Flake8Bugbear,
+    Flake8Builtins,
+    Flake8Comprehensions,
+    Flake8Docstrings,
+    Flake8Print,
+    Flake8Quotes,
+    Flake8Annotations,
+    PEP8Naming,
+    Pyupgrade,
+}
+
+impl FromStr for Plugin {
+    type Err = anyhow::Error;
+
+    fn from_str(string: &str) -> Result<Self, Self::Err> {
+        match string {
+            "flake8-bugbear" => Ok(Plugin::Flake8Bugbear),
+            "flake8-builtins" => Ok(Plugin::Flake8Builtins),
+            "flake8-comprehensions" => Ok(Plugin::Flake8Comprehensions),
+            "flake8-docstrings" => Ok(Plugin::Flake8Docstrings),
+            "flake8-print" => Ok(Plugin::Flake8Print),
+            "flake8-quotes" => Ok(Plugin::Flake8Quotes),
+            "flake8-annotations" => Ok(Plugin::Flake8Annotations),
+            "pep8-naming" => Ok(Plugin::PEP8Naming),
+            "pyupgrade" => Ok(Plugin::Pyupgrade),
+            _ => Err(anyhow!("Unknown plugin: {}", string)),
+        }
+    }
+}
+
+impl Plugin {
+    pub fn default(&self) -> CheckCodePrefix {
+        match self {
+            Plugin::Flake8Bugbear => CheckCodePrefix::B,
+            Plugin::Flake8Builtins => CheckCodePrefix::A,
+            Plugin::Flake8Comprehensions => CheckCodePrefix::C,
+            Plugin::Flake8Docstrings => CheckCodePrefix::D,
+            Plugin::Flake8Print => CheckCodePrefix::T,
+            Plugin::Flake8Quotes => CheckCodePrefix::Q,
+            Plugin::Flake8Annotations => CheckCodePrefix::ANN,
+            Plugin::PEP8Naming => CheckCodePrefix::N,
+            Plugin::Pyupgrade => CheckCodePrefix::U,
+        }
+    }
+
+    pub fn select(&self, flake8: &HashMap<String, Option<String>>) -> Vec<CheckCodePrefix> {
+        match self {
+            Plugin::Flake8Bugbear => vec![CheckCodePrefix::B],
+            Plugin::Flake8Builtins => vec![CheckCodePrefix::A],
+            Plugin::Flake8Comprehensions => vec![CheckCodePrefix::C],
+            Plugin::Flake8Docstrings => {
+                // Use the user-provided docstring.
+                for key in ["docstring-convention", "docstring_convention"] {
+                    if let Some(Some(value)) = flake8.get(key) {
+                        match DocstringConvention::from_str(value) {
+                            Ok(convention) => return convention.select(),
+                            Err(e) => {
+                                eprintln!("Unexpected '{key}' value: {value} ({e}");
+                                return vec![];
+                            }
+                        }
+                    }
+                }
+                // Default to PEP8.
+                DocstringConvention::PEP8.select()
+            }
+            Plugin::Flake8Print => vec![CheckCodePrefix::T],
+            Plugin::Flake8Quotes => vec![CheckCodePrefix::Q],
+            Plugin::Flake8Annotations => vec![CheckCodePrefix::ANN],
+            Plugin::PEP8Naming => vec![CheckCodePrefix::N],
+            Plugin::Pyupgrade => vec![CheckCodePrefix::U],
+        }
+    }
+}
+
+pub enum DocstringConvention {
+    All,
+    PEP8,
+    NumPy,
+    Google,
+}
+
+impl FromStr for DocstringConvention {
+    type Err = anyhow::Error;
+
+    fn from_str(string: &str) -> Result<Self, Self::Err> {
+        match string {
+            "all" => Ok(DocstringConvention::All),
+            "pep8" => Ok(DocstringConvention::PEP8),
+            "numpy" => Ok(DocstringConvention::NumPy),
+            "google" => Ok(DocstringConvention::Google),
+            _ => Err(anyhow!("Unknown docstring convention: {}", string)),
+        }
+    }
+}
+
+impl DocstringConvention {
+    fn select(&self) -> Vec<CheckCodePrefix> {
+        match self {
+            DocstringConvention::All => vec![CheckCodePrefix::D],
+            DocstringConvention::PEP8 => vec![
+                // All errors except D203, D212, D213, D214, D215, D404, D405, D406, D407, D408,
+                // D409, D410, D411, D413, D415, D416 and D417.
+                CheckCodePrefix::D100,
+                CheckCodePrefix::D101,
+                CheckCodePrefix::D102,
+                CheckCodePrefix::D103,
+                CheckCodePrefix::D104,
+                CheckCodePrefix::D105,
+                CheckCodePrefix::D106,
+                CheckCodePrefix::D107,
+                CheckCodePrefix::D200,
+                CheckCodePrefix::D201,
+                CheckCodePrefix::D202,
+                // CheckCodePrefix::D203,
+                CheckCodePrefix::D204,
+                CheckCodePrefix::D205,
+                CheckCodePrefix::D206,
+                CheckCodePrefix::D207,
+                CheckCodePrefix::D208,
+                CheckCodePrefix::D209,
+                CheckCodePrefix::D210,
+                CheckCodePrefix::D211,
+                // CheckCodePrefix::D212,
+                // CheckCodePrefix::D213,
+                // CheckCodePrefix::D214,
+                // CheckCodePrefix::D215,
+                CheckCodePrefix::D300,
+                CheckCodePrefix::D400,
+                CheckCodePrefix::D402,
+                CheckCodePrefix::D403,
+                // CheckCodePrefix::D404,
+                // CheckCodePrefix::D405,
+                // CheckCodePrefix::D406,
+                // CheckCodePrefix::D407,
+                // CheckCodePrefix::D408,
+                // CheckCodePrefix::D409,
+                // CheckCodePrefix::D410,
+                // CheckCodePrefix::D411,
+                CheckCodePrefix::D412,
+                // CheckCodePrefix::D413,
+                CheckCodePrefix::D414,
+                // CheckCodePrefix::D415,
+                // CheckCodePrefix::D416,
+                // CheckCodePrefix::D417,
+                CheckCodePrefix::D418,
+                CheckCodePrefix::D419,
+            ],
+            DocstringConvention::NumPy => vec![
+                // All errors except D107, D203, D212, D213, D402, D413, D415, D416, and D417.
+                CheckCodePrefix::D100,
+                CheckCodePrefix::D101,
+                CheckCodePrefix::D102,
+                CheckCodePrefix::D103,
+                CheckCodePrefix::D104,
+                CheckCodePrefix::D105,
+                CheckCodePrefix::D106,
+                // CheckCodePrefix::D107,
+                CheckCodePrefix::D200,
+                CheckCodePrefix::D201,
+                CheckCodePrefix::D202,
+                // CheckCodePrefix::D203,
+                CheckCodePrefix::D204,
+                CheckCodePrefix::D205,
+                CheckCodePrefix::D206,
+                CheckCodePrefix::D207,
+                CheckCodePrefix::D208,
+                CheckCodePrefix::D209,
+                CheckCodePrefix::D210,
+                CheckCodePrefix::D211,
+                // CheckCodePrefix::D212,
+                // CheckCodePrefix::D213,
+                CheckCodePrefix::D214,
+                CheckCodePrefix::D215,
+                CheckCodePrefix::D300,
+                CheckCodePrefix::D400,
+                // CheckCodePrefix::D402,
+                CheckCodePrefix::D403,
+                CheckCodePrefix::D404,
+                CheckCodePrefix::D405,
+                CheckCodePrefix::D406,
+                CheckCodePrefix::D407,
+                CheckCodePrefix::D408,
+                CheckCodePrefix::D409,
+                CheckCodePrefix::D410,
+                CheckCodePrefix::D411,
+                CheckCodePrefix::D412,
+                // CheckCodePrefix::D413,
+                CheckCodePrefix::D414,
+                // CheckCodePrefix::D415,
+                // CheckCodePrefix::D416,
+                // CheckCodePrefix::D417,
+                CheckCodePrefix::D418,
+                CheckCodePrefix::D419,
+            ],
+            DocstringConvention::Google => vec![
+                // All errors except D203, D204, D213, D215, D400, D401, D404, D406, D407, D408,
+                // D409 and D413.
+                CheckCodePrefix::D100,
+                CheckCodePrefix::D101,
+                CheckCodePrefix::D102,
+                CheckCodePrefix::D103,
+                CheckCodePrefix::D104,
+                CheckCodePrefix::D105,
+                CheckCodePrefix::D106,
+                CheckCodePrefix::D107,
+                CheckCodePrefix::D200,
+                CheckCodePrefix::D201,
+                CheckCodePrefix::D202,
+                // CheckCodePrefix::D203,
+                // CheckCodePrefix::D204,
+                CheckCodePrefix::D205,
+                CheckCodePrefix::D206,
+                CheckCodePrefix::D207,
+                CheckCodePrefix::D208,
+                CheckCodePrefix::D209,
+                CheckCodePrefix::D210,
+                CheckCodePrefix::D211,
+                CheckCodePrefix::D212,
+                // CheckCodePrefix::D213,
+                CheckCodePrefix::D214,
+                // CheckCodePrefix::D215,
+                CheckCodePrefix::D300,
+                // CheckCodePrefix::D400,
+                CheckCodePrefix::D402,
+                CheckCodePrefix::D403,
+                // CheckCodePrefix::D404,
+                CheckCodePrefix::D405,
+                // CheckCodePrefix::D406,
+                // CheckCodePrefix::D407,
+                // CheckCodePrefix::D408,
+                // CheckCodePrefix::D409,
+                CheckCodePrefix::D410,
+                CheckCodePrefix::D411,
+                CheckCodePrefix::D412,
+                // CheckCodePrefix::D413,
+                CheckCodePrefix::D414,
+                CheckCodePrefix::D415,
+                CheckCodePrefix::D416,
+                CheckCodePrefix::D417,
+                CheckCodePrefix::D418,
+                CheckCodePrefix::D419,
+            ],
+        }
+    }
+}
+
+/// Infer the enabled plugins based on user-provided options.
+///
+/// For example, if the user specified a `mypy-init-return` setting, we should
+/// infer that `flake8-annotations` is active.
+pub fn infer_plugins_from_options(flake8: &HashMap<String, Option<String>>) -> Vec<Plugin> {
+    let mut plugins = BTreeSet::new();
+    for key in flake8.keys() {
+        match key.as_str() {
+            // flake8-docstrings
+            "docstring-convention" | "docstring_convention" => {
+                plugins.insert(Plugin::Flake8Docstrings);
+            }
+            // flake8-builtins
+            "builtins-ignorelist" | "builtins_ignorelist" => {
+                plugins.insert(Plugin::Flake8Builtins);
+            }
+            // flake8-quotes
+            "quotes" | "inline-quotes" | "inline_quotes" => {
+                plugins.insert(Plugin::Flake8Quotes);
+            }
+            "multiline-quotes" | "multiline_quotes" => {
+                plugins.insert(Plugin::Flake8Quotes);
+            }
+            "docstring-quotes" | "docstring_quotes" => {
+                plugins.insert(Plugin::Flake8Quotes);
+            }
+            "avoid-escape" | "avoid_escape" => {
+                plugins.insert(Plugin::Flake8Quotes);
+            }
+            // flake8-annotations
+            "suppress-none-returning" | "suppress_none_returning" => {
+                plugins.insert(Plugin::Flake8Annotations);
+            }
+            "suppress-dummy-args" | "suppress_dummy_args" => {
+                plugins.insert(Plugin::Flake8Annotations);
+            }
+            "allow-untyped-defs" | "allow_untyped_defs" => {
+                plugins.insert(Plugin::Flake8Annotations);
+            }
+            "allow-untyped-nested" | "allow_untyped_nested" => {
+                plugins.insert(Plugin::Flake8Annotations);
+            }
+            "mypy-init-return" | "mypy_init_return" => {
+                plugins.insert(Plugin::Flake8Annotations);
+            }
+            "dispatch-decorators" | "dispatch_decorators" => {
+                plugins.insert(Plugin::Flake8Annotations);
+            }
+            "overload-decorators" | "overload_decorators" => {
+                plugins.insert(Plugin::Flake8Annotations);
+            }
+            "allow-star-arg-any" | "allow_star_arg_any" => {
+                plugins.insert(Plugin::Flake8Annotations);
+            }
+            // pep8-naming
+            "ignore-names" | "ignore_names" => {
+                plugins.insert(Plugin::PEP8Naming);
+            }
+            "classmethod-decorators" | "classmethod_decorators" => {
+                plugins.insert(Plugin::PEP8Naming);
+            }
+            "staticmethod-decorators" | "staticmethod_decorators" => {
+                plugins.insert(Plugin::PEP8Naming);
+            }
+            _ => {}
+        }
+    }
+    Vec::from_iter(plugins)
+}
+
+/// Infer the enabled plugins based on the referenced prefixes.
+///
+/// For example, if the user ignores `ANN101`, we should infer that
+/// `flake8-annotations` is active.
+pub fn infer_plugins_from_codes(codes: &BTreeSet<CheckCodePrefix>) -> Vec<Plugin> {
+    [
+        Plugin::Flake8Bugbear,
+        Plugin::Flake8Builtins,
+        Plugin::Flake8Comprehensions,
+        Plugin::Flake8Docstrings,
+        Plugin::Flake8Print,
+        Plugin::Flake8Quotes,
+        Plugin::Flake8Annotations,
+        Plugin::PEP8Naming,
+        Plugin::Pyupgrade,
+    ]
+    .into_iter()
+    .filter(|plugin| {
+        for prefix in codes {
+            if prefix
+                .codes()
+                .iter()
+                .any(|code| plugin.default().codes().contains(code))
+            {
+                return true;
+            }
+        }
+        false
+    })
+    .collect()
+}
+
+/// Resolve the set of enabled `CheckCodePrefix` values for the given plugins.
+pub fn resolve_select(
+    flake8: &HashMap<String, Option<String>>,
+    plugins: &[Plugin],
+) -> BTreeSet<CheckCodePrefix> {
+    // Include default Pyflakes and pycodestyle checks.
+    let mut select = BTreeSet::from([CheckCodePrefix::E, CheckCodePrefix::F, CheckCodePrefix::W]);
+
+    // Add prefix codes for every plugin.
+    for plugin in plugins {
+        select.extend(plugin.select(flake8));
+    }
+
+    select
+}
+
+#[cfg(test)]
+mod tests {
+    use std::collections::HashMap;
+
+    use crate::plugin::{infer_plugins_from_options, Plugin};
+
+    #[test]
+    fn it_infers_plugins() {
+        let actual = infer_plugins_from_options(&HashMap::from([(
+            "inline-quotes".to_string(),
+            Some("single".to_string()),
+        )]));
+        let expected = vec![Plugin::Flake8Quotes];
+        assert_eq!(actual, expected);
+
+        let actual = infer_plugins_from_options(&HashMap::from([(
+            "staticmethod-decorators".to_string(),
+            Some("[]".to_string()),
+        )]));
+        let expected = vec![Plugin::PEP8Naming];
+        assert_eq!(actual, expected);
+    }
+}

resources/test/fixtures/B003.py

@@ -0,0 +1,18 @@
+"""
+Should emit:
+B003 - on line 9
+"""
+
+import os
+from os import environ
+
+os.environ = {}
+environ = {}  # that's fine, assigning a new meaning to the module-level name
+
+
+class Object:
+    os = None
+
+
+o = Object()
+o.os.environ = {}

resources/test/fixtures/B004.py

@@ -0,0 +1,12 @@
+def this_is_a_bug():
+    o = object()
+    if hasattr(o, "__call__"):
+        print("Ooh, callable! Or is it?")
+    if getattr(o, "__call__", False):
+        print("Ooh, callable! Or is it?")
+
+
+def this_is_fine():
+    o = object()
+    if callable(o):
+        print("Ooh, this is actually callable.")

resources/test/fixtures/B005.py

@@ -0,0 +1,26 @@
+s = "qwe"
+s.strip(s)  # no warning
+s.strip("we")  # no warning
+s.strip(".facebook.com")  # warning
+s.strip("e")  # no warning
+s.strip("\n\t ")  # no warning
+s.strip(r"\n\t ")  # warning
+s.lstrip(s)  # no warning
+s.lstrip("we")  # no warning
+s.lstrip(".facebook.com")  # warning
+s.lstrip("e")  # no warning
+s.lstrip("\n\t ")  # no warning
+s.lstrip(r"\n\t ")  # warning
+s.rstrip(s)  # no warning
+s.rstrip("we")  # warning
+s.rstrip(".facebook.com")  # warning
+s.rstrip("e")  # no warning
+s.rstrip("\n\t ")  # no warning
+s.rstrip(r"\n\t ")  # warning
+
+from somewhere import other_type, strip
+
+strip("we")  # no warning
+other_type().lstrip()  # no warning
+other_type().rstrip(["a", "b", "c"])  # no warning
+other_type().strip("a", "b")  # no warning

resources/test/fixtures/B015.py

@@ -0,0 +1,27 @@
+assert 1 == 1
+
+1 == 1
+
+assert 1 in (1, 2)
+
+1 in (1, 2)
+
+
+if 1 == 2:
+    pass
+
+
+def test():
+    assert 1 in (1, 2)
+
+    1 in (1, 2)
+
+
+data = [x for x in [1, 2, 3] if x in (1, 2)]
+
+
+class TestClass:
+    1 == 1
+
+
+print(1 == 1)

resources/test/fixtures/B016.py

@@ -0,0 +1,11 @@
+"""
+Should emit:
+B016 - on lines 6, 7, and 8
+"""
+
+raise False
+raise 1
+raise "string"
+raise Exception(False)
+raise Exception(1)
+raise Exception("string")

resources/test/fixtures/B018.py

@@ -0,0 +1,59 @@
+class Foo1:
+    """abc"""
+
+
+class Foo2:
+    """abc"""
+
+    a = 2
+    "str"  # Str (no raise)
+    f"{int}"  # JoinedStr (no raise)
+    1j  # Number (complex)
+    1  # Number (int)
+    1.0  # Number (float)
+    b"foo"  # Binary
+    True  # NameConstant (True)
+    False  # NameConstant (False)
+    None  # NameConstant (None)
+    [1, 2]  # list
+    {1, 2}  # set
+    {"foo": "bar"}  # dict
+
+
+class Foo3:
+    123
+    a = 2
+    "str"
+    1
+
+
+def foo1():
+    """my docstring"""
+
+
+def foo2():
+    """my docstring"""
+    a = 2
+    "str"  # Str (no raise)
+    f"{int}"  # JoinedStr (no raise)
+    1j  # Number (complex)
+    1  # Number (int)
+    1.0  # Number (float)
+    b"foo"  # Binary
+    True  # NameConstant (True)
+    False  # NameConstant (False)
+    None  # NameConstant (None)
+    [1, 2]  # list
+    {1, 2}  # set
+    {"foo": "bar"}  # dict
+
+
+def foo3():
+    123
+    a = 2
+    "str"
+    3
+
+
+def foo4():
+    ...

resources/test/fixtures/E501.py

@@ -14,3 +14,38 @@ Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor i
 
 _ = "---------------------------------------------------------------------------AAAAAAA"
 _ = "---------------------------------------------------------------------------亜亜亜亜亜亜亜"
+
+
+def caller(string: str) -> None:
+    assert string is not None
+
+
+caller(
+    """
+    Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.
+    """,
+)
+
+
+caller(
+    """
+    Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.
+    """,  # noqa: E501
+)
+
+multiple_strings_per_line = {
+    # OK
+    "Lorem ipsum dolor": "sit amet",
+    # E501 Line too long
+    "Lorem ipsum dolor": "sit amet consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.",
+    # E501 Line too long
+    "Lorem ipsum dolor": """
+sit amet  consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.
+""",
+    # OK
+    "Lorem ipsum dolor": "sit amet consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.",  # noqa: E501
+    # OK
+    "Lorem ipsum dolor": """
+sit amet  consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.
+""",  # noqa: E501
+}

resources/test/fixtures/F632.py

@@ -3,3 +3,6 @@ if x is "abc":
 
 if 123 is not y:
     pass
+
+if "123" is x < 3:
+    pass

resources/test/fixtures/F821_3.py

@@ -0,0 +1,14 @@
+"""Test (edge case): accesses of object named `dict`."""
+
+# OK
+dict = {"parameters": {}}
+dict["parameters"]["userId"] = "userId"
+dict["parameters"]["itemId"] = "itemId"
+del dict["parameters"]["itemId"]
+
+# F821 Undefined name `key`
+# F821 Undefined name `value`
+x: dict["key", "value"]
+
+# OK
+x: dict[str, str]

resources/test/fixtures/N803.py

@@ -1,7 +1,7 @@
-def func(a, A):
-    return a, A
+def func(_, a, A):
+    return _, a, A
 
 
 class Class:
-    def method(self, a, A):
-        return a, A
+    def method(self, _, a, A):
+        return _, a, A

resources/test/fixtures/N804.py

@@ -1,19 +1,43 @@
+from abc import ABCMeta
+
+
 class Class:
-    @classmethod
-    def bad_class_method(this):
+    def bad_method(this):
+        pass
+
+    if False:
+
+        def extra_bad_method(this):
+            pass
+
+    def good_method(self):
         pass
 
     @classmethod
-    def good_class_method(cls):
-        pass
-
-    def method(self):
+    def class_method(cls):
         pass
 
     @staticmethod
     def static_method(x):
         return x
 
+    def __init__(self):
+        ...
+
+    def __new__(cls, *args, **kwargs):
+        ...
+
+    def __init_subclass__(self, default_name, **kwargs):
+        ...
+
+
+class MetaClass(ABCMeta):
+    def bad_method(self):
+        pass
+
+    def good_method(cls):
+        pass
+
 
 def func(x):
     return x

resources/test/fixtures/N805.py

@@ -1,11 +1,11 @@
-import random
+from abc import ABCMeta
 
 
 class Class:
     def bad_method(this):
         pass
 
-    if random.random(0, 2) == 0:
+    if False:
 
         def extra_bad_method(this):
             pass
@@ -21,6 +21,23 @@ class Class:
     def static_method(x):
         return x
 
+    def __init__(self):
+        ...
+
+    def __new__(cls, *args, **kwargs):
+        ...
+
+    def __init_subclass__(self, default_name, **kwargs):
+        ...
+
+
+class MetaClass(ABCMeta):
+    def bad_method(self):
+        pass
+
+    def good_method(cls):
+        pass
+
 
 def func(x):
     return x

resources/test/fixtures/RUF001.py

@@ -0,0 +1,6 @@
+x = "𝐁ad string"
+
+
+def f():
+    """Here's a comment with an unusual parenthesis: ）"""
+    ...

resources/test/fixtures/RUF002.py

@@ -0,0 +1,6 @@
+x = "𝐁ad string"
+
+
+def f():
+    """Here's a comment with an unusual parenthesis: ）"""
+    ...

resources/test/fixtures/U009_0.py

@@ -0,0 +1,3 @@
+# coding=utf8
+
+print('Hello world')

resources/test/fixtures/U009_1.py

@@ -0,0 +1,4 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+
+print('Hello world')

resources/test/fixtures/U009_2.py

@@ -0,0 +1,5 @@
+#!/usr/bin/python
+# A coding comment is only valid in the first two lines, so this one is not checked.
+# -*- coding: utf-8 -*-
+
+print('Hello world')

resources/test/fixtures/U009_3.py

@@ -0,0 +1,4 @@
+#!/usr/bin/python
+# -*- coding: something-else -*-
+
+print('Hello world')

resources/test/fixtures/W605_1.py

@@ -0,0 +1,35 @@
+#: W605:1:10
+regex = '\.png$'
+
+#: W605:2:1
+regex = '''
+\.png$
+'''
+
+#: W605:2:6
+f(
+    '\_'
+)
+
+#: W605:4:6
+"""
+multi-line
+literal
+with \_ somewhere
+in the middle
+"""
+
+#: Okay
+regex = r'\.png$'
+regex = '\\.png$'
+regex = r'''
+\.png$
+'''
+regex = r'''
+\\.png$
+'''
+s = '\\'
+regex = '\w'  # noqa
+regex = '''
+\w
+'''  # noqa

resources/test/fixtures/flake8_annotations/annotation_presence.py

@@ -0,0 +1,55 @@
+from typing import Type
+
+# Error
+def foo(a, b):
+    pass
+
+
+# Error
+def foo(a: int, b):
+    pass
+
+
+# Error
+def foo(a: int, b) -> int:
+    pass
+
+
+# Error
+def foo(a: int, b: int):
+    pass
+
+
+# Error
+def foo():
+    pass
+
+
+# OK
+def foo(a: int, b: int) -> int:
+    pass
+
+
+# OK
+def foo() -> int:
+    pass
+
+
+class Foo:
+    # OK
+    def foo(self: "Foo", a: int, b: int) -> int:
+        pass
+
+    # ANN101
+    def foo(self, a: int, b: int) -> int:
+        pass
+
+    # OK
+    @classmethod
+    def foo(cls: Type["Foo"], a: int, b: int) -> int:
+        pass
+
+    # ANN102
+    @classmethod
+    def foo(cls, a: int, b: int) -> int:
+        pass

resources/test/fixtures/flake8_annotations/mypy_init_return.py

@@ -0,0 +1,41 @@
+"""Test case expected to be run with `mypy_init_return = True`."""
+
+# Error
+class Foo:
+    def __init__(self):
+        ...
+
+
+# Error
+class Foo:
+    def __init__(self, foo):
+        ...
+
+
+# OK
+class Foo:
+    def __init__(self, foo) -> None:
+        ...
+
+
+# OK
+class Foo:
+    def __init__(self) -> None:
+        ...
+
+
+# OK
+class Foo:
+    def __init__(self, foo: int):
+        ...
+
+
+# OK
+class Foo:
+    def __init__(self, foo: int) -> None:
+        ...
+
+
+# Error
+def __init__(self, foo: int):
+    ...

resources/test/fixtures/flake8_annotations/suppress_dummy_args.py

@@ -0,0 +1,26 @@
+"""Test case expected to be run with `suppress_dummy_args = True`."""
+
+# OK
+def foo(_) -> None:
+    ...
+
+
+# OK
+def foo(*_) -> None:
+    ...
+
+
+# OK
+def foo(**_) -> None:
+    ...
+
+
+# OK
+def foo(a: int, _) -> None:
+    ...
+
+
+# OK
+def foo() -> None:
+    def bar(_) -> None:
+        ...

resources/test/fixtures/flake8_annotations/suppress_none_returning.py

@@ -0,0 +1,55 @@
+"""Test case expected to be run with `suppress_none_returning = True`."""
+
+# OK
+def foo():
+    a = 2 + 2
+
+
+# OK
+def foo():
+    return
+
+
+# OK
+def foo():
+    return None
+
+
+# OK
+def foo():
+    a = 2 + 2
+    if a == 4:
+        return
+    else:
+        return
+
+
+# OK
+def foo():
+    a = 2 + 2
+    if a == 4:
+        return None
+    else:
+        return
+
+
+# OK
+def foo():
+    def bar() -> bool:
+        return True
+
+    bar()
+
+
+# Error
+def foo():
+    return True
+
+
+# Error
+def foo():
+    a = 2 + 2
+    if a == 4:
+        return True
+    else:
+        return

ruff_dev/Cargo.toml

@@ -0,0 +1,16 @@
+[package]
+name = "ruff_dev"
+version = "0.0.107"
+edition = "2021"
+
+[dependencies]
+anyhow = { version = "1.0.60" }
+clap = { version = "4.0.1", features = ["derive"] }
+codegen = { version = "0.2.0" }
+itertools = { version = "0.10.5" }
+ruff = { path = ".." }
+rustpython-ast = { features = ["unparse"], git = "https://github.com/RustPython/RustPython.git", rev = "77b821a1941019fe34f73ce17cea013ae1b98fd0" }
+rustpython-common = { git = "https://github.com/RustPython/RustPython.git", rev = "77b821a1941019fe34f73ce17cea013ae1b98fd0" }
+rustpython-parser = { features = ["lalrpop"], git = "https://github.com/RustPython/RustPython.git", rev = "77b821a1941019fe34f73ce17cea013ae1b98fd0" }
+strum = { version = "0.24.1", features = ["strum_macros"] }
+strum_macros = { version = "0.24.3" }

ruff_dev/src/generate_check_code_prefix.rs

@@ -1,22 +1,39 @@
-//! Generate the CheckCodePrefix enum.
+//! Generate the `CheckCodePrefix` enum.
 
 use std::collections::{BTreeMap, BTreeSet};
+use std::fs::OpenOptions;
+use std::io::Write;
 
+use anyhow::Result;
+use clap::Parser;
 use codegen::{Scope, Type, Variant};
 use itertools::Itertools;
 use ruff::checks::CheckCode;
 use strum::IntoEnumIterator;
 
-fn main() {
+const FILE: &str = "src/checks_gen.rs";
+
+#[derive(Parser)]
+#[command(author, version, about, long_about = None)]
+pub struct Cli {
+    /// Write the generated source code to stdout (rather than to
+    /// `src/checks_gen.rs`).
+    #[arg(long)]
+    dry_run: bool,
+}
+
+pub fn main(cli: &Cli) -> Result<()> {
     // Build up a map from prefix to matching CheckCodes.
     let mut prefix_to_codes: BTreeMap<String, BTreeSet<CheckCode>> = Default::default();
     for check_code in CheckCode::iter() {
-        let as_ref = check_code.as_ref().to_string();
-        for i in 1..=as_ref.len() {
+        let as_ref: String = check_code.as_ref().to_string();
+        let prefix_len = as_ref
+            .chars()
+            .take_while(|char| char.is_alphabetic())
+            .count();
+        for i in prefix_len..=as_ref.len() {
             let prefix = as_ref[..i].to_string();
-            let entry = prefix_to_codes
-                .entry(prefix)
-                .or_insert_with(|| Default::default());
+            let entry = prefix_to_codes.entry(prefix).or_default();
             entry.insert(check_code.clone());
         }
     }
@@ -31,10 +48,12 @@ fn main() {
         .derive("Debug")
         .derive("PartialEq")
         .derive("Eq")
+        .derive("PartialOrd")
+        .derive("Ord")
         .derive("Clone")
         .derive("Serialize")
         .derive("Deserialize");
-    for (prefix, _) in &prefix_to_codes {
+    for prefix in prefix_to_codes.keys() {
         gen = gen.push_variant(Variant::new(prefix.to_string()));
     }
 
@@ -78,12 +97,13 @@ fn main() {
         .ret(Type::new("PrefixSpecificity"))
         .vis("pub")
         .line("match self {");
-    for (prefix, _) in &prefix_to_codes {
-        let specificity = match prefix.len() {
-            4 => "Explicit",
-            3 => "Tens",
-            2 => "Hundreds",
-            1 => "Category",
+    for prefix in prefix_to_codes.keys() {
+        let num_numeric = prefix.chars().filter(|char| char.is_numeric()).count();
+        let specificity = match num_numeric {
+            3 => "Explicit",
+            2 => "Tens",
+            1 => "Hundreds",
+            0 => "Category",
             _ => panic!("Invalid prefix: {}", prefix),
         };
         gen = gen.line(format!(
@@ -93,12 +113,28 @@ fn main() {
     }
     gen.line("}");
 
-    println!("//! File automatically generated by examples/generate_check_code_prefix.rs.");
-    println!();
-    println!("use serde::{{Serialize, Deserialize}};");
-    println!("use strum_macros::EnumString;");
-    println!();
-    println!("use crate::checks::CheckCode;");
-    println!();
-    println!("{}", scope.to_string());
+    // Construct the output contents.
+    let mut output = String::new();
+    output.push_str("//! File automatically generated by examples/generate_check_code_prefix.rs.");
+    output.push('\n');
+    output.push('\n');
+    output.push_str("use serde::{{Serialize, Deserialize}};");
+    output.push('\n');
+    output.push_str("use strum_macros::EnumString;");
+    output.push('\n');
+    output.push('\n');
+    output.push_str("use crate::checks::CheckCode;");
+    output.push('\n');
+    output.push('\n');
+    output.push_str(&scope.to_string());
+
+    // Write the output to `src/checks_gen.rs` (or stdout).
+    if cli.dry_run {
+        println!("{}", output);
+    } else {
+        let mut f = OpenOptions::new().write(true).truncate(true).open(FILE)?;
+        write!(f, "{}", output)?;
+    }
+
+    Ok(())
 }

ruff_dev/src/generate_rules_table.rs

@@ -0,0 +1,93 @@
+//! Generate a Markdown-compatible table of supported lint rules.
+
+use std::fs;
+use std::fs::OpenOptions;
+use std::io::Write;
+use std::path::PathBuf;
+
+use anyhow::Result;
+use clap::Args;
+use ruff::checks::{CheckCategory, CheckCode};
+use strum::IntoEnumIterator;
+
+const BEGIN_PRAGMA: &str = "<!-- Begin auto-generated sections. -->";
+const END_PRAGMA: &str = "<!-- End auto-generated sections. -->";
+
+#[derive(Args)]
+pub struct Cli {
+    /// Write the generated table to stdout (rather than to `README.md`).
+    #[arg(long)]
+    dry_run: bool,
+}
+
+pub fn main(cli: &Cli) -> Result<()> {
+    // Generate the table string.
+    let mut output = String::new();
+    for check_category in CheckCategory::iter() {
+        output.push_str(&format!("### {}", check_category.title()));
+        output.push('\n');
+        output.push('\n');
+
+        if let Some(url) = check_category.url() {
+            output.push_str(&format!(
+                "For more, see [{}]({}) on PyPI.",
+                check_category.title(),
+                url
+            ));
+            output.push('\n');
+            output.push('\n');
+        }
+
+        output.push_str("| Code | Name | Message | Fix |");
+        output.push('\n');
+        output.push_str("| ---- | ---- | ------- | --- |");
+        output.push('\n');
+
+        for check_code in CheckCode::iter() {
+            if check_code.category() == check_category {
+                let check_kind = check_code.kind();
+                let fix_token = if check_kind.fixable() { "🛠" } else { "" };
+                output.push_str(&format!(
+                    "| {} | {} | {} | {} |",
+                    check_kind.code().as_ref(),
+                    check_kind.as_ref(),
+                    check_kind.summary().replace('|', r"\|"),
+                    fix_token
+                ));
+                output.push('\n');
+            }
+        }
+        output.push('\n');
+    }
+
+    if cli.dry_run {
+        print!("{}", output);
+    } else {
+        // Read the existing file.
+        let file = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
+            .parent()
+            .expect("Failed to find root directory")
+            .join("README.md");
+        let existing = fs::read_to_string(&file)?;
+
+        // Extract the prefix.
+        let index = existing
+            .find(BEGIN_PRAGMA)
+            .expect("Unable to find begin pragma.");
+        let prefix = &existing[..index + BEGIN_PRAGMA.len()];
+
+        // Extract the suffix.
+        let index = existing
+            .find(END_PRAGMA)
+            .expect("Unable to find end pragma.");
+        let suffix = &existing[index..];
+
+        // Write the prefix, new contents, and suffix.
+        let mut f = OpenOptions::new().write(true).truncate(true).open(&file)?;
+        write!(f, "{}\n\n", prefix)?;
+        write!(f, "{}", output)?;
+        write!(f, "{}", suffix)?;
+    }
+
+    Ok(())
+}

ruff_dev/src/generate_source_code.rs

@@ -1,25 +1,25 @@
+//! Run round-trip source code generation on a given Python file.
+
+use std::fs;
 use std::path::PathBuf;
 
 use anyhow::Result;
-use clap::Parser;
+use clap::Args;
 use ruff::code_gen::SourceGenerator;
-use ruff::fs;
 use rustpython_parser::parser;
 
-#[derive(Debug, Parser)]
-struct Cli {
+#[derive(Args)]
+pub struct Cli {
+    /// Python file to round-trip.
     #[arg(required = true)]
     file: PathBuf,
 }
 
-fn main() -> Result<()> {
-    let cli = Cli::parse();
-
-    let contents = fs::read_file(&cli.file)?;
+pub fn main(cli: &Cli) -> Result<()> {
+    let contents = fs::read_to_string(&cli.file)?;
     let python_ast = parser::parse_program(&contents, &cli.file.to_string_lossy())?;
     let mut generator = SourceGenerator::new();
     generator.unparse_suite(&python_ast)?;
     println!("{}", generator.generate()?);
-
     Ok(())
 }

ruff_dev/src/lib.rs

@@ -0,0 +1,5 @@
+pub mod generate_check_code_prefix;
+pub mod generate_rules_table;
+pub mod generate_source_code;
+pub mod print_ast;
+pub mod print_tokens;

ruff_dev/src/main.rs

@@ -0,0 +1,39 @@
+use anyhow::Result;
+use clap::{Parser, Subcommand};
+use ruff_dev::{
+    generate_check_code_prefix, generate_rules_table, generate_source_code, print_ast, print_tokens,
+};
+
+#[derive(Parser)]
+#[command(author, version, about, long_about = None)]
+#[command(propagate_version = true)]
+struct Cli {
+    #[command(subcommand)]
+    command: Commands,
+}
+
+#[derive(Subcommand)]
+enum Commands {
+    /// Generate the `CheckCodePrefix` enum.
+    GenerateCheckCodePrefix(generate_check_code_prefix::Cli),
+    /// Generate a Markdown-compatible table of supported lint rules.
+    GenerateRulesTable(generate_rules_table::Cli),
+    /// Run round-trip source code generation on a given Python file.
+    GenerateSourceCode(generate_source_code::Cli),
+    /// Print the AST for a given Python file.
+    PrintAST(print_ast::Cli),
+    /// Print the token stream for a given Python file.
+    PrintTokens(print_tokens::Cli),
+}
+
+fn main() -> Result<()> {
+    let cli = Cli::parse();
+    match &cli.command {
+        Commands::GenerateCheckCodePrefix(args) => generate_check_code_prefix::main(args)?,
+        Commands::GenerateRulesTable(args) => generate_rules_table::main(args)?,
+        Commands::GenerateSourceCode(args) => generate_source_code::main(args)?,
+        Commands::PrintAST(args) => print_ast::main(args)?,
+        Commands::PrintTokens(args) => print_tokens::main(args)?,
+    }
+    Ok(())
+}

ruff_dev/src/print_ast.rs

@@ -1,25 +1,22 @@
 //! Print the AST for a given Python file.
 
+use std::fs;
 use std::path::PathBuf;
 
 use anyhow::Result;
-use clap::Parser;
-use ruff::fs;
+use clap::Args;
 use rustpython_parser::parser;
 
-#[derive(Debug, Parser)]
-struct Cli {
+#[derive(Args)]
+pub struct Cli {
+    /// Python file for which to generate the AST.
     #[arg(required = true)]
     file: PathBuf,
 }
 
-fn main() -> Result<()> {
-    let cli = Cli::parse();
-
-    let contents = fs::read_file(&cli.file)?;
+pub fn main(cli: &Cli) -> Result<()> {
+    let contents = fs::read_to_string(&cli.file)?;
     let python_ast = parser::parse_program(&contents, &cli.file.to_string_lossy())?;
-
     println!("{:#?}", python_ast);
-
     Ok(())
 }

ruff_dev/src/print_tokens.rs

@@ -1,25 +1,23 @@
 //! Print the token stream for a given Python file.
 
+use std::fs;
 use std::path::PathBuf;
 
 use anyhow::Result;
-use clap::Parser;
-use ruff::fs;
+use clap::Args;
 use rustpython_parser::lexer;
 
-#[derive(Debug, Parser)]
-struct Cli {
+#[derive(Args)]
+pub struct Cli {
+    /// Python file for which to generate the AST.
     #[arg(required = true)]
     file: PathBuf,
 }
 
-fn main() -> Result<()> {
-    let cli = Cli::parse();
-
-    let contents = fs::read_file(&cli.file)?;
+pub fn main(cli: &Cli) -> Result<()> {
+    let contents = fs::read_to_string(&cli.file)?;
     for (_, tok, _) in lexer::make_tokenizer(&contents).flatten() {
         println!("{:#?}", tok);
     }
-
     Ok(())
 }

rust-toolchain

@@ -1 +1 @@
-1.64.0
+1.65.0

src/ast/types.rs

@@ -1,6 +1,7 @@
 use std::collections::BTreeMap;
 use std::sync::atomic::{AtomicUsize, Ordering};
 
+use rustpython_ast::{Expr, Keyword};
 use rustpython_parser::ast::{Located, Location};
 
 fn id() -> usize {
@@ -30,24 +31,33 @@ pub struct FunctionScope {
     pub uses_locals: bool,
 }
 
-#[derive(Clone, Debug)]
-pub enum ScopeKind {
-    Class,
-    Function(FunctionScope),
-    Generator,
-    Module,
+#[derive(Clone, Debug, Default)]
+pub struct ClassScope<'a> {
+    pub name: &'a str,
+    pub bases: &'a [Expr],
+    pub keywords: &'a [Keyword],
+    pub decorator_list: &'a [Expr],
 }
 
 #[derive(Clone, Debug)]
-pub struct Scope {
+pub enum ScopeKind<'a> {
+    Class(ClassScope<'a>),
+    Function(FunctionScope),
+    Generator,
+    Module,
+    Arg,
+}
+
+#[derive(Clone, Debug)]
+pub struct Scope<'a> {
     pub id: usize,
-    pub kind: ScopeKind,
+    pub kind: ScopeKind<'a>,
     pub import_starred: bool,
     pub values: BTreeMap<String, Binding>,
 }
 
-impl Scope {
-    pub fn new(kind: ScopeKind) -> Self {
+impl<'a> Scope<'a> {
+    pub fn new(kind: ScopeKind<'a>) -> Self {
         Scope {
             id: id(),
             kind,
@@ -90,10 +100,6 @@ pub struct Binding {
     pub used: Option<(usize, Range)>,
 }
 
-pub trait CheckLocator {
-    fn locate_check(&self, default: Range) -> Range;
-}
-
 #[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord)]
 pub enum ImportKind {
     Import,

src/autofix/fixer.rs

@@ -1,10 +1,14 @@
+use std::borrow::Cow;
 use std::collections::BTreeSet;
 
 use itertools::Itertools;
+use ropey::RopeBuilder;
 use rustpython_parser::ast::Location;
 
+use crate::ast::types::Range;
 use crate::autofix::{Fix, Patch};
 use crate::checks::Check;
+use crate::source_code_locator::SourceCodeLocator;
 
 // TODO(charlie): The model here is awkward because `Apply` is only relevant at
 // higher levels in the execution flow.
@@ -36,24 +40,28 @@ impl From<bool> for Mode {
 }
 
 /// Auto-fix errors in a file, and write the fixed source code to disk.
-pub fn fix_file(checks: &mut [Check], contents: &str) -> Option<String> {
+pub fn fix_file<'a>(
+    checks: &'a mut [Check],
+    locator: &'a SourceCodeLocator<'a>,
+) -> Option<Cow<'a, str>> {
     if checks.iter().all(|check| check.fix.is_none()) {
         return None;
     }
 
     Some(apply_fixes(
         checks.iter_mut().filter_map(|check| check.fix.as_mut()),
-        contents,
+        locator,
     ))
 }
 
 /// Apply a series of fixes.
-fn apply_fixes<'a>(fixes: impl Iterator<Item = &'a mut Fix>, contents: &str) -> String {
-    let lines: Vec<&str> = contents.lines().collect();
-
-    let mut output: String = Default::default();
-    let mut last_pos: Location = Default::default();
-    let mut applied: BTreeSet<&Patch> = Default::default();
+fn apply_fixes<'a>(
+    fixes: impl Iterator<Item = &'a mut Fix>,
+    locator: &'a SourceCodeLocator<'a>,
+) -> Cow<'a, str> {
+    let mut output = RopeBuilder::new();
+    let mut last_pos: Location = Location::new(1, 0);
+    let mut applied: BTreeSet<&Patch> = BTreeSet::new();
 
     for fix in fixes.sorted_by_key(|fix| fix.patch.location) {
         // If we already applied an identical fix as part of another correction, skip
@@ -69,44 +77,27 @@ fn apply_fixes<'a>(fixes: impl Iterator<Item = &'a mut Fix>, contents: &str) ->
             continue;
         }
 
-        if fix.patch.location.row() > last_pos.row() {
-            if last_pos.row() > 0 || last_pos.column() > 0 {
-                output.push_str(&lines[last_pos.row() - 1][last_pos.column()..]);
-                output.push('\n');
-            }
-            for line in &lines[last_pos.row()..fix.patch.location.row() - 1] {
-                output.push_str(line);
-                output.push('\n');
-            }
-            output.push_str(&lines[fix.patch.location.row() - 1][..fix.patch.location.column()]);
-            output.push_str(&fix.patch.content);
-        } else {
-            output.push_str(
-                &lines[last_pos.row() - 1][last_pos.column()..fix.patch.location.column()],
-            );
-            output.push_str(&fix.patch.content);
-        }
-        last_pos = fix.patch.end_location;
+        // Add all contents from `last_pos` to `fix.patch.location`.
+        let slice = locator.slice_source_code_range(&Range {
+            location: last_pos,
+            end_location: fix.patch.location,
+        });
+        output.append(&slice);
 
+        // Add the patch itself.
+        output.append(&fix.patch.content);
+
+        // Track that the fix was applied.
+        last_pos = fix.patch.end_location;
         applied.insert(&fix.patch);
         fix.applied = true;
     }
 
-    if last_pos.row() > 0
-        && (last_pos.row() - 1) < lines.len()
-        && (last_pos.row() > 0 || last_pos.column() > 0)
-    {
-        output.push_str(&lines[last_pos.row() - 1][last_pos.column()..]);
-        output.push('\n');
-    }
-    if last_pos.row() < lines.len() {
-        for line in &lines[last_pos.row()..] {
-            output.push_str(line);
-            output.push('\n');
-        }
-    }
+    // Add the remaining content.
+    let slice = locator.slice_source_code_at(&last_pos);
+    output.append(&slice);
 
-    output
+    Cow::from(output.finish())
 }
 
 #[cfg(test)]
@@ -116,11 +107,13 @@ mod tests {
 
     use crate::autofix::fixer::apply_fixes;
     use crate::autofix::{Fix, Patch};
+    use crate::SourceCodeLocator;
 
     #[test]
     fn empty_file() -> Result<()> {
         let mut fixes = vec![];
-        let actual = apply_fixes(fixes.iter_mut(), "");
+        let locator = SourceCodeLocator::new("");
+        let actual = apply_fixes(fixes.iter_mut(), &locator);
         let expected = "";
 
         assert_eq!(actual, expected);
@@ -138,12 +131,12 @@ mod tests {
             },
             applied: false,
         }];
-        let actual = apply_fixes(
-            fixes.iter_mut(),
+        let locator = SourceCodeLocator::new(
             "class A(object):
         ...
 ",
         );
+        let actual = apply_fixes(fixes.iter_mut(), &locator);
 
         let expected = "class A(Bar):
         ...
@@ -164,12 +157,12 @@ mod tests {
             },
             applied: false,
         }];
-        let actual = apply_fixes(
-            fixes.iter_mut(),
+        let locator = SourceCodeLocator::new(
             "class A(object):
         ...
 ",
         );
+        let actual = apply_fixes(fixes.iter_mut(), &locator);
 
         let expected = "class A:
         ...
@@ -200,12 +193,12 @@ mod tests {
                 applied: false,
             },
         ];
-        let actual = apply_fixes(
-            fixes.iter_mut(),
+        let locator = SourceCodeLocator::new(
             "class A(object, object):
         ...
 ",
         );
+        let actual = apply_fixes(fixes.iter_mut(), &locator);
 
         let expected = "class A:
         ...
@@ -236,12 +229,12 @@ mod tests {
                 applied: false,
             },
         ];
-        let actual = apply_fixes(
-            fixes.iter_mut(),
+        let locator = SourceCodeLocator::new(
             "class A(object):
     ...
 ",
         );
+        let actual = apply_fixes(fixes.iter_mut(), &locator);
 
         let expected = "class A:
     ...

src/check_lines.rs

@@ -2,6 +2,8 @@
 
 use std::collections::BTreeMap;
 
+use once_cell::sync::Lazy;
+use regex::Regex;
 use rustpython_parser::ast::Location;
 
 use crate::ast::types::Range;
@@ -11,6 +13,10 @@ use crate::noqa;
 use crate::noqa::Directive;
 use crate::settings::Settings;
 
+// Regex from PEP263
+static CODING_COMMENT_REGEX: Lazy<Regex> =
+    Lazy::new(|| Regex::new(r"^[ \t\f]*#.*?coding[:=][ \t]*utf-?8").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 {
@@ -34,6 +40,7 @@ pub fn check_lines(
     settings: &Settings,
     autofix: &fixer::Mode,
 ) {
+    let enforce_unnecessary_coding_comment = settings.enabled.contains(&CheckCode::U009);
     let enforce_line_too_long = settings.enabled.contains(&CheckCode::E501);
     let enforce_noqa = settings.enabled.contains(&CheckCode::M001);
 
@@ -52,6 +59,30 @@ pub fn check_lines(
             .map(|lineno| lineno - 1)
             .unwrap_or(lineno);
 
+        // Enforce unnecessary coding comments (U009).
+        if enforce_unnecessary_coding_comment {
+            if lineno < 2 {
+                // PEP3120 makes utf-8 the default encoding.
+                if CODING_COMMENT_REGEX.is_match(line) {
+                    let line_length = line.len();
+                    let mut check = Check::new(
+                        CheckKind::PEP3120UnnecessaryCodingComment,
+                        Range {
+                            location: Location::new(lineno + 1, 0),
+                            end_location: Location::new(lineno + 1, line_length + 1),
+                        },
+                    );
+                    if autofix.patch() {
+                        check.amend(Fix::deletion(
+                            Location::new(lineno + 1, 0),
+                            Location::new(lineno + 1, line_length + 1),
+                        ));
+                    }
+                    line_checks.push(check);
+                }
+            }
+        }
+
         if enforce_noqa {
             noqa_directives
                 .entry(noqa_lineno)
@@ -82,7 +113,7 @@ pub fn check_lines(
             }
         }
 
-        // Enforce line length.
+        // Enforce line length violations (E501).
         if enforce_line_too_long {
             let line_length = line.chars().count();
             if should_enforce_line_length(line, line_length, settings.line_length) {

src/check_tokens.rs

@@ -2,37 +2,54 @@
 
 use rustpython_parser::lexer::{LexResult, Tok};
 
+use crate::autofix::fixer;
 use crate::checks::{Check, CheckCode};
-use crate::flake8_quotes::docstring_detection::StateMachine;
+use crate::lex::docstring_detection::StateMachine;
 use crate::source_code_locator::SourceCodeLocator;
-use crate::{flake8_quotes, pycodestyle, Settings};
+use crate::{flake8_quotes, pycodestyle, rules, Settings};
 
 pub fn check_tokens(
     checks: &mut Vec<Check>,
     locator: &SourceCodeLocator,
     tokens: &[LexResult],
     settings: &Settings,
+    autofix: &fixer::Mode,
 ) {
-    let enforce_invalid_escape_sequence = settings.enabled.contains(&CheckCode::W605);
+    let enforce_ambiguous_unicode_character = settings.enabled.contains(&CheckCode::RUF001)
+        || settings.enabled.contains(&CheckCode::RUF002);
     let enforce_quotes = settings.enabled.contains(&CheckCode::Q000)
-        | settings.enabled.contains(&CheckCode::Q001)
-        | settings.enabled.contains(&CheckCode::Q002)
-        | settings.enabled.contains(&CheckCode::Q003);
+        || settings.enabled.contains(&CheckCode::Q001)
+        || settings.enabled.contains(&CheckCode::Q002)
+        || settings.enabled.contains(&CheckCode::Q003);
+    let enforce_invalid_escape_sequence = settings.enabled.contains(&CheckCode::W605);
 
     let mut state_machine: StateMachine = Default::default();
     for (start, tok, end) in tokens.iter().flatten() {
-        // W605
-        if enforce_invalid_escape_sequence {
+        let is_docstring = if enforce_ambiguous_unicode_character || enforce_quotes {
+            state_machine.consume(tok)
+        } else {
+            false
+        };
+
+        // RUF001, RUF002
+        if enforce_ambiguous_unicode_character {
             if matches!(tok, Tok::String { .. }) {
-                checks.extend(pycodestyle::checks::invalid_escape_sequence(
-                    locator, start, end,
-                ));
+                for check in rules::checks::ambiguous_unicode_character(
+                    locator,
+                    start,
+                    end,
+                    is_docstring,
+                    autofix.patch(),
+                ) {
+                    if settings.enabled.contains(check.kind.code()) {
+                        checks.push(check);
+                    }
+                }
             }
         }
 
         // flake8-quotes
         if enforce_quotes {
-            let is_docstring = state_machine.consume(tok);
             if matches!(tok, Tok::String { .. }) {
                 if let Some(check) = flake8_quotes::checks::quotes(
                     locator,
@@ -47,5 +64,14 @@ pub fn check_tokens(
                 }
             }
         }
+
+        // W605
+        if enforce_invalid_escape_sequence {
+            if matches!(tok, Tok::String { .. }) {
+                checks.extend(pycodestyle::checks::invalid_escape_sequence(
+                    locator, start, end,
+                ));
+            }
+        }
     }
 }

src/checks.rs

@@ -78,12 +78,19 @@ pub enum CheckCode {
     A003,
     // flake8-bugbear
     B002,
+    B003,
+    B004,
+    B005,
     B006,
     B007,
+    B008,
     B011,
     B013,
     B014,
+    B015,
+    B016,
     B017,
+    B018,
     B025,
     // flake8-comprehensions
     C400,
@@ -110,6 +117,17 @@ pub enum CheckCode {
     Q001,
     Q002,
     Q003,
+    // flake8-annotations
+    ANN001,
+    ANN002,
+    ANN003,
+    ANN101,
+    ANN102,
+    ANN201,
+    ANN202,
+    ANN204,
+    ANN205,
+    ANN206,
     // pyupgrade
     U001,
     U002,
@@ -119,6 +137,7 @@ pub enum CheckCode {
     U006,
     U007,
     U008,
+    U009,
     // pydocstyle
     D100,
     D101,
@@ -180,6 +199,9 @@ pub enum CheckCode {
     N816,
     N817,
     N818,
+    // Ruff
+    RUF001,
+    RUF002,
     // Meta
     M001,
 }
@@ -187,8 +209,7 @@ pub enum CheckCode {
 #[derive(EnumIter, Debug, PartialEq, Eq)]
 pub enum CheckCategory {
     Pyflakes,
-    PycodestyleError,
-    PycodestyleWarning,
+    Pycodestyle,
     Pydocstyle,
     Pyupgrade,
     PEP8Naming,
@@ -197,26 +218,55 @@ pub enum CheckCategory {
     Flake8Builtins,
     Flake8Print,
     Flake8Quotes,
+    Flake8Annotations,
+    Ruff,
     Meta,
 }
 
 impl CheckCategory {
     pub fn title(&self) -> &'static str {
         match self {
-            CheckCategory::PycodestyleError => "pycodestyle (error)",
-            CheckCategory::PycodestyleWarning => "pycodestyle (warning)",
+            CheckCategory::Pycodestyle => "pycodestyle",
             CheckCategory::Pyflakes => "Pyflakes",
             CheckCategory::Flake8Builtins => "flake8-builtins",
             CheckCategory::Flake8Bugbear => "flake8-bugbear",
             CheckCategory::Flake8Comprehensions => "flake8-comprehensions",
             CheckCategory::Flake8Print => "flake8-print",
             CheckCategory::Flake8Quotes => "flake8-quotes",
+            CheckCategory::Flake8Annotations => "flake8-annotations",
             CheckCategory::Pyupgrade => "pyupgrade",
             CheckCategory::Pydocstyle => "pydocstyle",
             CheckCategory::PEP8Naming => "pep8-naming",
+            CheckCategory::Ruff => "Ruff-specific rules",
             CheckCategory::Meta => "Meta rules",
         }
     }
+
+    pub fn url(&self) -> Option<&'static str> {
+        match self {
+            CheckCategory::Pycodestyle => Some("https://pypi.org/project/pycodestyle/2.9.1/"),
+            CheckCategory::Pyflakes => Some("https://pypi.org/project/pyflakes/2.5.0/"),
+            CheckCategory::Flake8Builtins => {
+                Some("https://pypi.org/project/flake8-builtins/2.0.1/")
+            }
+            CheckCategory::Flake8Bugbear => {
+                Some("https://pypi.org/project/flake8-bugbear/22.10.27/")
+            }
+            CheckCategory::Flake8Comprehensions => {
+                Some("https://pypi.org/project/flake8-comprehensions/3.10.1/")
+            }
+            CheckCategory::Flake8Print => Some("https://pypi.org/project/flake8-print/5.0.0/"),
+            CheckCategory::Flake8Quotes => Some("https://pypi.org/project/flake8-quotes/3.3.1/"),
+            CheckCategory::Flake8Annotations => {
+                Some("https://pypi.org/project/flake8-annotations/2.9.1/")
+            }
+            CheckCategory::Pyupgrade => Some("https://pypi.org/project/pyupgrade/3.2.0/"),
+            CheckCategory::Pydocstyle => Some("https://pypi.org/project/pydocstyle/6.1.1/"),
+            CheckCategory::PEP8Naming => Some("https://pypi.org/project/pep8-naming/0.13.2/"),
+            CheckCategory::Ruff => None,
+            CheckCategory::Meta => None,
+        }
+    }
 }
 
 #[allow(clippy::upper_case_acronyms)]
@@ -288,12 +338,19 @@ pub enum CheckKind {
     BuiltinAttributeShadowing(String),
     // flake8-bugbear
     UnaryPrefixIncrement,
+    AssignmentToOsEnviron,
+    UnreliableCallableCheck,
+    StripWithMultiCharacters,
     MutableArgumentDefault,
     UnusedLoopControlVariable(String),
+    FunctionCallArgumentDefault,
     DoNotAssertFalse,
     RedundantTupleInExceptionHandler(String),
     DuplicateHandlerException(Vec<String>),
+    UselessComparison,
+    CannotRaiseLiteral,
     NoAssertRaisesException,
+    UselessExpression,
     DuplicateTryBlockException(String),
     // flake8-comprehensions
     UnnecessaryGeneratorList,
@@ -320,6 +377,17 @@ pub enum CheckKind {
     BadQuotesMultilineString(Quote),
     BadQuotesDocstring(Quote),
     AvoidQuoteEscape,
+    // flake8-annotations
+    MissingTypeFunctionArgument(String),
+    MissingTypeArgs(String),
+    MissingTypeKwargs(String),
+    MissingTypeSelf(String),
+    MissingTypeCls(String),
+    MissingReturnTypePublicFunction(String),
+    MissingReturnTypePrivateFunction(String),
+    MissingReturnTypeMagicMethod(String),
+    MissingReturnTypeStaticMethod(String),
+    MissingReturnTypeClassMethod(String),
     // pyupgrade
     TypeOfPrimitive(Primitive),
     UnnecessaryAbspath,
@@ -329,6 +397,7 @@ pub enum CheckKind {
     UsePEP585Annotation(String),
     UsePEP604Annotation,
     SuperCallWithParameters,
+    PEP3120UnnecessaryCodingComment,
     // pydocstyle
     BlankLineAfterLastSection(String),
     BlankLineAfterSection(String),
@@ -390,6 +459,9 @@ pub enum CheckKind {
     MixedCaseVariableInGlobalScope(String),
     CamelcaseImportedAsAcronym(String, String),
     ErrorSuffixOnExceptionName(String),
+    // Ruff
+    AmbiguousUnicodeCharacterString(char, char),
+    AmbiguousUnicodeCharacterDocstring(char, char),
     // Meta
     UnusedNOQA(Option<Vec<String>>),
 }
@@ -399,12 +471,16 @@ impl CheckCode {
     /// physical lines).
     pub fn lint_source(&self) -> &'static LintSource {
         match self {
-            CheckCode::E501 | CheckCode::W292 | CheckCode::M001 => &LintSource::Lines,
-            CheckCode::W605
-            | CheckCode::Q000
+            CheckCode::E501 | CheckCode::W292 | CheckCode::M001 | CheckCode::U009 => {
+                &LintSource::Lines
+            }
+            CheckCode::Q000
             | CheckCode::Q001
             | CheckCode::Q002
-            | CheckCode::Q003 => &LintSource::Tokens,
+            | CheckCode::Q003
+            | CheckCode::W605
+            | CheckCode::RUF001
+            | CheckCode::RUF002 => &LintSource::Tokens,
             CheckCode::E902 => &LintSource::FileSystem,
             _ => &LintSource::AST,
         }
@@ -468,14 +544,21 @@ impl CheckCode {
             CheckCode::A003 => CheckKind::BuiltinAttributeShadowing("...".to_string()),
             // flake8-bugbear
             CheckCode::B002 => CheckKind::UnaryPrefixIncrement,
+            CheckCode::B003 => CheckKind::AssignmentToOsEnviron,
+            CheckCode::B004 => CheckKind::UnreliableCallableCheck,
+            CheckCode::B005 => CheckKind::StripWithMultiCharacters,
             CheckCode::B006 => CheckKind::MutableArgumentDefault,
             CheckCode::B007 => CheckKind::UnusedLoopControlVariable("i".to_string()),
+            CheckCode::B008 => CheckKind::FunctionCallArgumentDefault,
             CheckCode::B011 => CheckKind::DoNotAssertFalse,
             CheckCode::B013 => {
                 CheckKind::RedundantTupleInExceptionHandler("ValueError".to_string())
             }
             CheckCode::B014 => CheckKind::DuplicateHandlerException(vec!["ValueError".to_string()]),
+            CheckCode::B015 => CheckKind::UselessComparison,
+            CheckCode::B016 => CheckKind::CannotRaiseLiteral,
             CheckCode::B017 => CheckKind::NoAssertRaisesException,
+            CheckCode::B018 => CheckKind::UselessExpression,
             CheckCode::B025 => CheckKind::DuplicateTryBlockException("Exception".to_string()),
             // flake8-comprehensions
             CheckCode::C400 => CheckKind::UnnecessaryGeneratorList,
@@ -515,6 +598,17 @@ impl CheckCode {
             CheckCode::Q001 => CheckKind::BadQuotesMultilineString(Quote::Double),
             CheckCode::Q002 => CheckKind::BadQuotesDocstring(Quote::Double),
             CheckCode::Q003 => CheckKind::AvoidQuoteEscape,
+            // flake8-annotations
+            CheckCode::ANN001 => CheckKind::MissingTypeFunctionArgument("...".to_string()),
+            CheckCode::ANN002 => CheckKind::MissingTypeArgs("...".to_string()),
+            CheckCode::ANN003 => CheckKind::MissingTypeKwargs("...".to_string()),
+            CheckCode::ANN101 => CheckKind::MissingTypeSelf("...".to_string()),
+            CheckCode::ANN102 => CheckKind::MissingTypeCls("...".to_string()),
+            CheckCode::ANN201 => CheckKind::MissingReturnTypePublicFunction("...".to_string()),
+            CheckCode::ANN202 => CheckKind::MissingReturnTypePrivateFunction("...".to_string()),
+            CheckCode::ANN204 => CheckKind::MissingReturnTypeMagicMethod("...".to_string()),
+            CheckCode::ANN205 => CheckKind::MissingReturnTypeStaticMethod("...".to_string()),
+            CheckCode::ANN206 => CheckKind::MissingReturnTypeClassMethod("...".to_string()),
             // pyupgrade
             CheckCode::U001 => CheckKind::UselessMetaclassType,
             CheckCode::U002 => CheckKind::UnnecessaryAbspath,
@@ -527,6 +621,7 @@ impl CheckCode {
             CheckCode::U006 => CheckKind::UsePEP585Annotation("List".to_string()),
             CheckCode::U007 => CheckKind::UsePEP604Annotation,
             CheckCode::U008 => CheckKind::SuperCallWithParameters,
+            CheckCode::U009 => CheckKind::PEP3120UnnecessaryCodingComment,
             // pydocstyle
             CheckCode::D100 => CheckKind::PublicModule,
             CheckCode::D101 => CheckKind::PublicClass,
@@ -604,6 +699,9 @@ impl CheckCode {
                 CheckKind::CamelcaseImportedAsAcronym("...".to_string(), "...".to_string())
             }
             CheckCode::N818 => CheckKind::ErrorSuffixOnExceptionName("...".to_string()),
+            // Ruff
+            CheckCode::RUF001 => CheckKind::AmbiguousUnicodeCharacterString('𝐁', 'B'),
+            CheckCode::RUF002 => CheckKind::AmbiguousUnicodeCharacterDocstring('𝐁', 'B'),
             // Meta
             CheckCode::M001 => CheckKind::UnusedNOQA(None),
         }
@@ -611,22 +709,22 @@ impl CheckCode {
 
     pub fn category(&self) -> CheckCategory {
         match self {
-            CheckCode::E402 => CheckCategory::PycodestyleError,
-            CheckCode::E501 => CheckCategory::PycodestyleError,
-            CheckCode::E711 => CheckCategory::PycodestyleError,
-            CheckCode::E712 => CheckCategory::PycodestyleError,
-            CheckCode::E713 => CheckCategory::PycodestyleError,
-            CheckCode::E714 => CheckCategory::PycodestyleError,
-            CheckCode::E721 => CheckCategory::PycodestyleError,
-            CheckCode::E722 => CheckCategory::PycodestyleError,
-            CheckCode::E731 => CheckCategory::PycodestyleError,
-            CheckCode::E741 => CheckCategory::PycodestyleError,
-            CheckCode::E742 => CheckCategory::PycodestyleError,
-            CheckCode::E743 => CheckCategory::PycodestyleError,
-            CheckCode::E902 => CheckCategory::PycodestyleError,
-            CheckCode::E999 => CheckCategory::PycodestyleError,
-            CheckCode::W292 => CheckCategory::PycodestyleWarning,
-            CheckCode::W605 => CheckCategory::PycodestyleWarning,
+            CheckCode::E402 => CheckCategory::Pycodestyle,
+            CheckCode::E501 => CheckCategory::Pycodestyle,
+            CheckCode::E711 => CheckCategory::Pycodestyle,
+            CheckCode::E712 => CheckCategory::Pycodestyle,
+            CheckCode::E713 => CheckCategory::Pycodestyle,
+            CheckCode::E714 => CheckCategory::Pycodestyle,
+            CheckCode::E721 => CheckCategory::Pycodestyle,
+            CheckCode::E722 => CheckCategory::Pycodestyle,
+            CheckCode::E731 => CheckCategory::Pycodestyle,
+            CheckCode::E741 => CheckCategory::Pycodestyle,
+            CheckCode::E742 => CheckCategory::Pycodestyle,
+            CheckCode::E743 => CheckCategory::Pycodestyle,
+            CheckCode::E902 => CheckCategory::Pycodestyle,
+            CheckCode::E999 => CheckCategory::Pycodestyle,
+            CheckCode::W292 => CheckCategory::Pycodestyle,
+            CheckCode::W605 => CheckCategory::Pycodestyle,
             CheckCode::F401 => CheckCategory::Pyflakes,
             CheckCode::F402 => CheckCategory::Pyflakes,
             CheckCode::F403 => CheckCategory::Pyflakes,
@@ -659,12 +757,19 @@ impl CheckCode {
             CheckCode::A002 => CheckCategory::Flake8Builtins,
             CheckCode::A003 => CheckCategory::Flake8Builtins,
             CheckCode::B002 => CheckCategory::Flake8Bugbear,
+            CheckCode::B003 => CheckCategory::Flake8Bugbear,
+            CheckCode::B004 => CheckCategory::Flake8Bugbear,
+            CheckCode::B005 => CheckCategory::Flake8Bugbear,
             CheckCode::B006 => CheckCategory::Flake8Bugbear,
             CheckCode::B007 => CheckCategory::Flake8Bugbear,
+            CheckCode::B008 => CheckCategory::Flake8Bugbear,
             CheckCode::B011 => CheckCategory::Flake8Bugbear,
             CheckCode::B013 => CheckCategory::Flake8Bugbear,
             CheckCode::B014 => CheckCategory::Flake8Bugbear,
+            CheckCode::B015 => CheckCategory::Flake8Bugbear,
+            CheckCode::B016 => CheckCategory::Flake8Bugbear,
             CheckCode::B017 => CheckCategory::Flake8Bugbear,
+            CheckCode::B018 => CheckCategory::Flake8Bugbear,
             CheckCode::B025 => CheckCategory::Flake8Bugbear,
             CheckCode::C400 => CheckCategory::Flake8Comprehensions,
             CheckCode::C401 => CheckCategory::Flake8Comprehensions,
@@ -688,6 +793,16 @@ impl CheckCode {
             CheckCode::Q001 => CheckCategory::Flake8Quotes,
             CheckCode::Q002 => CheckCategory::Flake8Quotes,
             CheckCode::Q003 => CheckCategory::Flake8Quotes,
+            CheckCode::ANN001 => CheckCategory::Flake8Annotations,
+            CheckCode::ANN002 => CheckCategory::Flake8Annotations,
+            CheckCode::ANN003 => CheckCategory::Flake8Annotations,
+            CheckCode::ANN101 => CheckCategory::Flake8Annotations,
+            CheckCode::ANN102 => CheckCategory::Flake8Annotations,
+            CheckCode::ANN201 => CheckCategory::Flake8Annotations,
+            CheckCode::ANN202 => CheckCategory::Flake8Annotations,
+            CheckCode::ANN204 => CheckCategory::Flake8Annotations,
+            CheckCode::ANN205 => CheckCategory::Flake8Annotations,
+            CheckCode::ANN206 => CheckCategory::Flake8Annotations,
             CheckCode::U001 => CheckCategory::Pyupgrade,
             CheckCode::U002 => CheckCategory::Pyupgrade,
             CheckCode::U003 => CheckCategory::Pyupgrade,
@@ -696,6 +811,7 @@ impl CheckCode {
             CheckCode::U006 => CheckCategory::Pyupgrade,
             CheckCode::U007 => CheckCategory::Pyupgrade,
             CheckCode::U008 => CheckCategory::Pyupgrade,
+            CheckCode::U009 => CheckCategory::Pyupgrade,
             CheckCode::D100 => CheckCategory::Pydocstyle,
             CheckCode::D101 => CheckCategory::Pydocstyle,
             CheckCode::D102 => CheckCategory::Pydocstyle,
@@ -755,6 +871,8 @@ impl CheckCode {
             CheckCode::N816 => CheckCategory::PEP8Naming,
             CheckCode::N817 => CheckCategory::PEP8Naming,
             CheckCode::N818 => CheckCategory::PEP8Naming,
+            CheckCode::RUF001 => CheckCategory::Ruff,
+            CheckCode::RUF002 => CheckCategory::Ruff,
             CheckCode::M001 => CheckCategory::Meta,
         }
     }
@@ -816,12 +934,19 @@ impl CheckKind {
             CheckKind::BuiltinAttributeShadowing(_) => &CheckCode::A003,
             // flake8-bugbear
             CheckKind::UnaryPrefixIncrement => &CheckCode::B002,
+            CheckKind::AssignmentToOsEnviron => &CheckCode::B003,
+            CheckKind::UnreliableCallableCheck => &CheckCode::B004,
+            CheckKind::StripWithMultiCharacters => &CheckCode::B005,
             CheckKind::MutableArgumentDefault => &CheckCode::B006,
             CheckKind::UnusedLoopControlVariable(_) => &CheckCode::B007,
+            CheckKind::FunctionCallArgumentDefault => &CheckCode::B008,
             CheckKind::DoNotAssertFalse => &CheckCode::B011,
             CheckKind::RedundantTupleInExceptionHandler(_) => &CheckCode::B013,
             CheckKind::DuplicateHandlerException(_) => &CheckCode::B014,
+            CheckKind::UselessComparison => &CheckCode::B015,
+            CheckKind::CannotRaiseLiteral => &CheckCode::B016,
             CheckKind::NoAssertRaisesException => &CheckCode::B017,
+            CheckKind::UselessExpression => &CheckCode::B018,
             CheckKind::DuplicateTryBlockException(_) => &CheckCode::B025,
             // flake8-comprehensions
             CheckKind::UnnecessaryGeneratorList => &CheckCode::C400,
@@ -848,6 +973,17 @@ impl CheckKind {
             CheckKind::BadQuotesMultilineString(_) => &CheckCode::Q001,
             CheckKind::BadQuotesDocstring(_) => &CheckCode::Q002,
             CheckKind::AvoidQuoteEscape => &CheckCode::Q003,
+            // flake8-annotations
+            CheckKind::MissingTypeFunctionArgument(_) => &CheckCode::ANN001,
+            CheckKind::MissingTypeArgs(_) => &CheckCode::ANN002,
+            CheckKind::MissingTypeKwargs(_) => &CheckCode::ANN003,
+            CheckKind::MissingTypeSelf(_) => &CheckCode::ANN101,
+            CheckKind::MissingTypeCls(_) => &CheckCode::ANN102,
+            CheckKind::MissingReturnTypePublicFunction(_) => &CheckCode::ANN201,
+            CheckKind::MissingReturnTypePrivateFunction(_) => &CheckCode::ANN202,
+            CheckKind::MissingReturnTypeMagicMethod(_) => &CheckCode::ANN204,
+            CheckKind::MissingReturnTypeStaticMethod(_) => &CheckCode::ANN205,
+            CheckKind::MissingReturnTypeClassMethod(_) => &CheckCode::ANN206,
             // pyupgrade
             CheckKind::TypeOfPrimitive(_) => &CheckCode::U003,
             CheckKind::UnnecessaryAbspath => &CheckCode::U002,
@@ -857,6 +993,7 @@ impl CheckKind {
             CheckKind::UsePEP604Annotation => &CheckCode::U007,
             CheckKind::UselessObjectInheritance(_) => &CheckCode::U004,
             CheckKind::SuperCallWithParameters => &CheckCode::U008,
+            CheckKind::PEP3120UnnecessaryCodingComment => &CheckCode::U009,
             // pydocstyle
             CheckKind::BlankLineAfterLastSection(_) => &CheckCode::D413,
             CheckKind::BlankLineAfterSection(_) => &CheckCode::D410,
@@ -918,6 +1055,9 @@ impl CheckKind {
             CheckKind::MixedCaseVariableInGlobalScope(..) => &CheckCode::N816,
             CheckKind::CamelcaseImportedAsAcronym(..) => &CheckCode::N817,
             CheckKind::ErrorSuffixOnExceptionName(..) => &CheckCode::N818,
+            // Ruff
+            CheckKind::AmbiguousUnicodeCharacterString(..) => &CheckCode::RUF001,
+            CheckKind::AmbiguousUnicodeCharacterDocstring(..) => &CheckCode::RUF002,
             // Meta
             CheckKind::UnusedNOQA(_) => &CheckCode::M001,
         }
@@ -1078,6 +1218,16 @@ impl CheckKind {
                                                 increment. Writing `++n` is equivalent to \
                                                 `+(+(n))`, which equals `n`. You meant `n += 1`."
                 .to_string(),
+            CheckKind::AssignmentToOsEnviron => {
+                "Assigning to `os.environ` doesn't clear the environment.".to_string()
+            }
+            CheckKind::UnreliableCallableCheck => " Using `hasattr(x, '__call__')` to test if x \
+                                                   is callable is unreliable. Use `callable(x)` \
+                                                   for consistent results."
+                .to_string(),
+            CheckKind::StripWithMultiCharacters => "Using `.strip()` with multi-character strings \
+                                                    is misleading the reader."
+                .to_string(),
             CheckKind::MutableArgumentDefault => {
                 "Do not use mutable data structures for argument defaults.".to_string()
             }
@@ -1085,6 +1235,9 @@ impl CheckKind {
                 "Loop control variable `{name}` not used within the loop body. If this is \
                  intended, start the name with an underscore."
             ),
+            CheckKind::FunctionCallArgumentDefault => {
+                "Do not perform function calls in argument defaults.".to_string()
+            }
             CheckKind::DoNotAssertFalse => "Do not `assert False` (`python -O` removes these \
                                             calls), raise `AssertionError()`"
                 .to_string(),
@@ -1094,6 +1247,13 @@ impl CheckKind {
                      `except ({name},):`."
                 )
             }
+            CheckKind::UselessComparison => "Pointless comparison. This comparison does nothing \
+                                             but waste CPU instructions. Either prepend `assert` \
+                                             or remove it."
+                .to_string(),
+            CheckKind::CannotRaiseLiteral => "Cannot raise a literal. Did you intend to return it \
+                                              or raise an Exception?"
+                .to_string(),
             CheckKind::DuplicateHandlerException(names) => {
                 if names.len() == 1 {
                     let name = &names[0];
@@ -1110,6 +1270,9 @@ impl CheckKind {
                  `assertRaisesRegex`, or use the context manager form of `assertRaises`."
                     .to_string()
             }
+            CheckKind::UselessExpression => {
+                "Found useless expression. Either assign it to a variable or remove it.".to_string()
+            }
             CheckKind::DuplicateTryBlockException(name) => {
                 format!("try-except block with duplicate exception `{name}`")
             }
@@ -1213,6 +1376,35 @@ impl CheckKind {
             CheckKind::AvoidQuoteEscape => {
                 "Change outer quotes to avoid escaping inner quotes".to_string()
             }
+            // flake8-annotations
+            CheckKind::MissingTypeFunctionArgument(name) => {
+                format!("Missing type annotation for function argument `{name}`")
+            }
+            CheckKind::MissingTypeArgs(name) => format!("Missing type annotation for `*{name}`"),
+            CheckKind::MissingTypeKwargs(name) => {
+                format!("Missing type annotation for `**{name}`")
+            }
+            CheckKind::MissingTypeSelf(name) => {
+                format!("Missing type annotation for `{name}` in method")
+            }
+            CheckKind::MissingTypeCls(name) => {
+                format!("Missing type annotation for `{name}` in classmethod")
+            }
+            CheckKind::MissingReturnTypePublicFunction(name) => {
+                format!("Missing return type annotation for public function `{name}`")
+            }
+            CheckKind::MissingReturnTypePrivateFunction(name) => {
+                format!("Missing return type annotation for private function `{name}`")
+            }
+            CheckKind::MissingReturnTypeMagicMethod(name) => {
+                format!("Missing return type annotation for magic method `{name}`")
+            }
+            CheckKind::MissingReturnTypeStaticMethod(name) => {
+                format!("Missing return type annotation for staticmethod `{name}`")
+            }
+            CheckKind::MissingReturnTypeClassMethod(name) => {
+                format!("Missing return type annotation for classmethod `{name}`")
+            }
             // pyupgrade
             CheckKind::TypeOfPrimitive(primitive) => {
                 format!("Use `{}` instead of `type(...)`", primitive.builtin())
@@ -1398,6 +1590,22 @@ impl CheckKind {
             CheckKind::ErrorSuffixOnExceptionName(name) => {
                 format!("Exception name `{name}` should be named with an Error suffix")
             }
+            CheckKind::PEP3120UnnecessaryCodingComment => {
+                "utf-8 encoding declaration is unnecessary".to_string()
+            }
+            // Ruff
+            CheckKind::AmbiguousUnicodeCharacterString(confusable, representant) => {
+                format!(
+                    "String contains ambiguous unicode character '{confusable}' (did you mean \
+                     '{representant}'?)"
+                )
+            }
+            CheckKind::AmbiguousUnicodeCharacterDocstring(confusable, representant) => {
+                format!(
+                    "Docstring contains ambiguous unicode character '{confusable}' (did you mean \
+                     '{representant}'?)"
+                )
+            }
             // Meta
             CheckKind::UnusedNOQA(codes) => match codes {
                 None => "Unused `noqa` directive".to_string(),
@@ -1439,7 +1647,9 @@ impl CheckKind {
     pub fn fixable(&self) -> bool {
         matches!(
             self,
-            CheckKind::BlankLineAfterLastSection(_)
+            CheckKind::AmbiguousUnicodeCharacterString(_, _)
+                | CheckKind::AmbiguousUnicodeCharacterDocstring(_, _)
+                | CheckKind::BlankLineAfterLastSection(_)
                 | CheckKind::BlankLineAfterSection(_)
                 | CheckKind::BlankLineAfterSummary
                 | CheckKind::BlankLineBeforeSection(_)
@@ -1461,6 +1671,7 @@ impl CheckKind {
                 | CheckKind::OneBlankLineBeforeClass(_)
                 | CheckKind::PPrintFound
                 | CheckKind::PrintFound
+                | CheckKind::RaiseNotImplemented
                 | CheckKind::SectionNameEndsInColon(_)
                 | CheckKind::SectionNotOverIndented(_)
                 | CheckKind::SectionUnderlineAfterName(_)
@@ -1487,6 +1698,8 @@ impl CheckKind {
                 | CheckKind::UsePEP604Annotation
                 | CheckKind::UselessMetaclassType
                 | CheckKind::UselessObjectInheritance(_)
+                | CheckKind::PEP3120UnnecessaryCodingComment
+                | CheckKind::IsLiteral
         )
     }
 }

src/checks_gen.rs

@@ -1,11 +1,11 @@
 //! File automatically generated by examples/generate_check_code_prefix.rs.
 
 use serde::{Deserialize, Serialize};
-use strum_macros::{AsRefStr, EnumString};
+use strum_macros::EnumString;
 
 use crate::checks::CheckCode;
 
-#[derive(AsRefStr, EnumString, Debug, PartialEq, Eq, Clone, Serialize, Deserialize)]
+#[derive(EnumString, Debug, PartialEq, Eq, PartialOrd, Ord, Clone, Serialize, Deserialize)]
 pub enum CheckCodePrefix {
     A,
     A0,
@@ -13,17 +13,41 @@ pub enum CheckCodePrefix {
     A001,
     A002,
     A003,
+    ANN,
+    ANN0,
+    ANN00,
+    ANN001,
+    ANN002,
+    ANN003,
+    ANN1,
+    ANN10,
+    ANN101,
+    ANN102,
+    ANN2,
+    ANN20,
+    ANN201,
+    ANN202,
+    ANN204,
+    ANN205,
+    ANN206,
     B,
     B0,
     B00,
     B002,
+    B003,
+    B004,
+    B005,
     B006,
     B007,
+    B008,
     B01,
     B011,
     B013,
     B014,
+    B015,
+    B016,
     B017,
+    B018,
     B02,
     B025,
     C,
@@ -204,6 +228,11 @@ pub enum CheckCodePrefix {
     Q001,
     Q002,
     Q003,
+    RUF,
+    RUF0,
+    RUF00,
+    RUF001,
+    RUF002,
     T,
     T2,
     T20,
@@ -220,6 +249,7 @@ pub enum CheckCodePrefix {
     U006,
     U007,
     U008,
+    U009,
     W,
     W2,
     W29,
@@ -246,42 +276,112 @@ impl CheckCodePrefix {
             CheckCodePrefix::A001 => vec![CheckCode::A001],
             CheckCodePrefix::A002 => vec![CheckCode::A002],
             CheckCodePrefix::A003 => vec![CheckCode::A003],
+            CheckCodePrefix::ANN => vec![
+                CheckCode::ANN001,
+                CheckCode::ANN002,
+                CheckCode::ANN003,
+                CheckCode::ANN101,
+                CheckCode::ANN102,
+                CheckCode::ANN201,
+                CheckCode::ANN202,
+                CheckCode::ANN204,
+                CheckCode::ANN205,
+                CheckCode::ANN206,
+            ],
+            CheckCodePrefix::ANN0 => vec![CheckCode::ANN001, CheckCode::ANN002, CheckCode::ANN003],
+            CheckCodePrefix::ANN00 => vec![CheckCode::ANN001, CheckCode::ANN002, CheckCode::ANN003],
+            CheckCodePrefix::ANN001 => vec![CheckCode::ANN001],
+            CheckCodePrefix::ANN002 => vec![CheckCode::ANN002],
+            CheckCodePrefix::ANN003 => vec![CheckCode::ANN003],
+            CheckCodePrefix::ANN1 => vec![CheckCode::ANN101, CheckCode::ANN102],
+            CheckCodePrefix::ANN10 => vec![CheckCode::ANN101, CheckCode::ANN102],
+            CheckCodePrefix::ANN101 => vec![CheckCode::ANN101],
+            CheckCodePrefix::ANN102 => vec![CheckCode::ANN102],
+            CheckCodePrefix::ANN2 => vec![
+                CheckCode::ANN201,
+                CheckCode::ANN202,
+                CheckCode::ANN204,
+                CheckCode::ANN205,
+                CheckCode::ANN206,
+            ],
+            CheckCodePrefix::ANN20 => vec![
+                CheckCode::ANN201,
+                CheckCode::ANN202,
+                CheckCode::ANN204,
+                CheckCode::ANN205,
+                CheckCode::ANN206,
+            ],
+            CheckCodePrefix::ANN201 => vec![CheckCode::ANN201],
+            CheckCodePrefix::ANN202 => vec![CheckCode::ANN202],
+            CheckCodePrefix::ANN204 => vec![CheckCode::ANN204],
+            CheckCodePrefix::ANN205 => vec![CheckCode::ANN205],
+            CheckCodePrefix::ANN206 => vec![CheckCode::ANN206],
             CheckCodePrefix::B => vec![
                 CheckCode::B002,
+                CheckCode::B003,
+                CheckCode::B004,
+                CheckCode::B005,
                 CheckCode::B006,
                 CheckCode::B007,
+                CheckCode::B008,
                 CheckCode::B011,
                 CheckCode::B013,
                 CheckCode::B014,
+                CheckCode::B015,
+                CheckCode::B016,
                 CheckCode::B017,
+                CheckCode::B018,
                 CheckCode::B025,
             ],
             CheckCodePrefix::B0 => vec![
                 CheckCode::B002,
+                CheckCode::B003,
+                CheckCode::B004,
+                CheckCode::B005,
                 CheckCode::B006,
                 CheckCode::B007,
+                CheckCode::B008,
                 CheckCode::B011,
                 CheckCode::B013,
                 CheckCode::B014,
+                CheckCode::B015,
+                CheckCode::B016,
                 CheckCode::B017,
+                CheckCode::B018,
                 CheckCode::B025,
             ],
-            CheckCodePrefix::B00 => vec![CheckCode::B002, CheckCode::B006, CheckCode::B007],
+            CheckCodePrefix::B00 => vec![
+                CheckCode::B002,
+                CheckCode::B003,
+                CheckCode::B004,
+                CheckCode::B005,
+                CheckCode::B006,
+                CheckCode::B007,
+                CheckCode::B008,
+            ],
             CheckCodePrefix::B002 => vec![CheckCode::B002],
+            CheckCodePrefix::B003 => vec![CheckCode::B003],
+            CheckCodePrefix::B004 => vec![CheckCode::B004],
+            CheckCodePrefix::B005 => vec![CheckCode::B005],
             CheckCodePrefix::B006 => vec![CheckCode::B006],
             CheckCodePrefix::B007 => vec![CheckCode::B007],
-            CheckCodePrefix::B01 => {
-                vec![
-                    CheckCode::B011,
-                    CheckCode::B013,
-                    CheckCode::B014,
-                    CheckCode::B017,
-                ]
-            }
+            CheckCodePrefix::B008 => vec![CheckCode::B008],
+            CheckCodePrefix::B01 => vec![
+                CheckCode::B011,
+                CheckCode::B013,
+                CheckCode::B014,
+                CheckCode::B015,
+                CheckCode::B016,
+                CheckCode::B017,
+                CheckCode::B018,
+            ],
             CheckCodePrefix::B011 => vec![CheckCode::B011],
             CheckCodePrefix::B013 => vec![CheckCode::B013],
             CheckCodePrefix::B014 => vec![CheckCode::B014],
+            CheckCodePrefix::B015 => vec![CheckCode::B015],
+            CheckCodePrefix::B016 => vec![CheckCode::B016],
             CheckCodePrefix::B017 => vec![CheckCode::B017],
+            CheckCodePrefix::B018 => vec![CheckCode::B018],
             CheckCodePrefix::B02 => vec![CheckCode::B025],
             CheckCodePrefix::B025 => vec![CheckCode::B025],
             CheckCodePrefix::C => vec![
@@ -584,14 +684,12 @@ impl CheckCodePrefix {
                 CheckCode::E742,
                 CheckCode::E743,
             ],
-            CheckCodePrefix::E71 => {
-                vec![
-                    CheckCode::E711,
-                    CheckCode::E712,
-                    CheckCode::E713,
-                    CheckCode::E714,
-                ]
-            }
+            CheckCodePrefix::E71 => vec![
+                CheckCode::E711,
+                CheckCode::E712,
+                CheckCode::E713,
+                CheckCode::E714,
+            ],
             CheckCodePrefix::E711 => vec![CheckCode::E711],
             CheckCodePrefix::E712 => vec![CheckCode::E712],
             CheckCodePrefix::E713 => vec![CheckCode::E713],
@@ -684,14 +782,12 @@ impl CheckCodePrefix {
             CheckCodePrefix::F62 => vec![CheckCode::F621, CheckCode::F622],
             CheckCodePrefix::F621 => vec![CheckCode::F621],
             CheckCodePrefix::F622 => vec![CheckCode::F622],
-            CheckCodePrefix::F63 => {
-                vec![
-                    CheckCode::F631,
-                    CheckCode::F632,
-                    CheckCode::F633,
-                    CheckCode::F634,
-                ]
-            }
+            CheckCodePrefix::F63 => vec![
+                CheckCode::F631,
+                CheckCode::F632,
+                CheckCode::F633,
+                CheckCode::F634,
+            ],
             CheckCodePrefix::F631 => vec![CheckCode::F631],
             CheckCodePrefix::F632 => vec![CheckCode::F632],
             CheckCodePrefix::F633 => vec![CheckCode::F633],
@@ -808,34 +904,33 @@ impl CheckCodePrefix {
             CheckCodePrefix::N816 => vec![CheckCode::N816],
             CheckCodePrefix::N817 => vec![CheckCode::N817],
             CheckCodePrefix::N818 => vec![CheckCode::N818],
-            CheckCodePrefix::Q => {
-                vec![
-                    CheckCode::Q000,
-                    CheckCode::Q001,
-                    CheckCode::Q002,
-                    CheckCode::Q003,
-                ]
-            }
-            CheckCodePrefix::Q0 => {
-                vec![
-                    CheckCode::Q000,
-                    CheckCode::Q001,
-                    CheckCode::Q002,
-                    CheckCode::Q003,
-                ]
-            }
-            CheckCodePrefix::Q00 => {
-                vec![
-                    CheckCode::Q000,
-                    CheckCode::Q001,
-                    CheckCode::Q002,
-                    CheckCode::Q003,
-                ]
-            }
+            CheckCodePrefix::Q => vec![
+                CheckCode::Q000,
+                CheckCode::Q001,
+                CheckCode::Q002,
+                CheckCode::Q003,
+            ],
+            CheckCodePrefix::Q0 => vec![
+                CheckCode::Q000,
+                CheckCode::Q001,
+                CheckCode::Q002,
+                CheckCode::Q003,
+            ],
+            CheckCodePrefix::Q00 => vec![
+                CheckCode::Q000,
+                CheckCode::Q001,
+                CheckCode::Q002,
+                CheckCode::Q003,
+            ],
             CheckCodePrefix::Q000 => vec![CheckCode::Q000],
             CheckCodePrefix::Q001 => vec![CheckCode::Q001],
             CheckCodePrefix::Q002 => vec![CheckCode::Q002],
             CheckCodePrefix::Q003 => vec![CheckCode::Q003],
+            CheckCodePrefix::RUF => vec![CheckCode::RUF001, CheckCode::RUF002],
+            CheckCodePrefix::RUF0 => vec![CheckCode::RUF001, CheckCode::RUF002],
+            CheckCodePrefix::RUF00 => vec![CheckCode::RUF001, CheckCode::RUF002],
+            CheckCodePrefix::RUF001 => vec![CheckCode::RUF001],
+            CheckCodePrefix::RUF002 => vec![CheckCode::RUF002],
             CheckCodePrefix::T => vec![CheckCode::T201, CheckCode::T203],
             CheckCodePrefix::T2 => vec![CheckCode::T201, CheckCode::T203],
             CheckCodePrefix::T20 => vec![CheckCode::T201, CheckCode::T203],
@@ -850,6 +945,7 @@ impl CheckCodePrefix {
                 CheckCode::U006,
                 CheckCode::U007,
                 CheckCode::U008,
+                CheckCode::U009,
             ],
             CheckCodePrefix::U0 => vec![
                 CheckCode::U001,
@@ -860,6 +956,7 @@ impl CheckCodePrefix {
                 CheckCode::U006,
                 CheckCode::U007,
                 CheckCode::U008,
+                CheckCode::U009,
             ],
             CheckCodePrefix::U00 => vec![
                 CheckCode::U001,
@@ -870,6 +967,7 @@ impl CheckCodePrefix {
                 CheckCode::U006,
                 CheckCode::U007,
                 CheckCode::U008,
+                CheckCode::U009,
             ],
             CheckCodePrefix::U001 => vec![CheckCode::U001],
             CheckCodePrefix::U002 => vec![CheckCode::U002],
@@ -879,6 +977,7 @@ impl CheckCodePrefix {
             CheckCodePrefix::U006 => vec![CheckCode::U006],
             CheckCodePrefix::U007 => vec![CheckCode::U007],
             CheckCodePrefix::U008 => vec![CheckCode::U008],
+            CheckCodePrefix::U009 => vec![CheckCode::U009],
             CheckCodePrefix::W => vec![CheckCode::W292, CheckCode::W605],
             CheckCodePrefix::W2 => vec![CheckCode::W292],
             CheckCodePrefix::W29 => vec![CheckCode::W292],
@@ -899,17 +998,41 @@ impl CheckCodePrefix {
             CheckCodePrefix::A001 => PrefixSpecificity::Explicit,
             CheckCodePrefix::A002 => PrefixSpecificity::Explicit,
             CheckCodePrefix::A003 => PrefixSpecificity::Explicit,
+            CheckCodePrefix::ANN => PrefixSpecificity::Category,
+            CheckCodePrefix::ANN0 => PrefixSpecificity::Hundreds,
+            CheckCodePrefix::ANN00 => PrefixSpecificity::Tens,
+            CheckCodePrefix::ANN001 => PrefixSpecificity::Explicit,
+            CheckCodePrefix::ANN002 => PrefixSpecificity::Explicit,
+            CheckCodePrefix::ANN003 => PrefixSpecificity::Explicit,
+            CheckCodePrefix::ANN1 => PrefixSpecificity::Hundreds,
+            CheckCodePrefix::ANN10 => PrefixSpecificity::Tens,
+            CheckCodePrefix::ANN101 => PrefixSpecificity::Explicit,
+            CheckCodePrefix::ANN102 => PrefixSpecificity::Explicit,
+            CheckCodePrefix::ANN2 => PrefixSpecificity::Hundreds,
+            CheckCodePrefix::ANN20 => PrefixSpecificity::Tens,
+            CheckCodePrefix::ANN201 => PrefixSpecificity::Explicit,
+            CheckCodePrefix::ANN202 => PrefixSpecificity::Explicit,
+            CheckCodePrefix::ANN204 => PrefixSpecificity::Explicit,
+            CheckCodePrefix::ANN205 => PrefixSpecificity::Explicit,
+            CheckCodePrefix::ANN206 => PrefixSpecificity::Explicit,
             CheckCodePrefix::B => PrefixSpecificity::Category,
             CheckCodePrefix::B0 => PrefixSpecificity::Hundreds,
             CheckCodePrefix::B00 => PrefixSpecificity::Tens,
             CheckCodePrefix::B002 => PrefixSpecificity::Explicit,
+            CheckCodePrefix::B003 => PrefixSpecificity::Explicit,
+            CheckCodePrefix::B004 => PrefixSpecificity::Explicit,
+            CheckCodePrefix::B005 => PrefixSpecificity::Explicit,
             CheckCodePrefix::B006 => PrefixSpecificity::Explicit,
             CheckCodePrefix::B007 => PrefixSpecificity::Explicit,
+            CheckCodePrefix::B008 => PrefixSpecificity::Explicit,
             CheckCodePrefix::B01 => PrefixSpecificity::Tens,
             CheckCodePrefix::B011 => PrefixSpecificity::Explicit,
             CheckCodePrefix::B013 => PrefixSpecificity::Explicit,
             CheckCodePrefix::B014 => PrefixSpecificity::Explicit,
+            CheckCodePrefix::B015 => PrefixSpecificity::Explicit,
+            CheckCodePrefix::B016 => PrefixSpecificity::Explicit,
             CheckCodePrefix::B017 => PrefixSpecificity::Explicit,
+            CheckCodePrefix::B018 => PrefixSpecificity::Explicit,
             CheckCodePrefix::B02 => PrefixSpecificity::Tens,
             CheckCodePrefix::B025 => PrefixSpecificity::Explicit,
             CheckCodePrefix::C => PrefixSpecificity::Category,
@@ -1090,6 +1213,11 @@ impl CheckCodePrefix {
             CheckCodePrefix::Q001 => PrefixSpecificity::Explicit,
             CheckCodePrefix::Q002 => PrefixSpecificity::Explicit,
             CheckCodePrefix::Q003 => PrefixSpecificity::Explicit,
+            CheckCodePrefix::RUF => PrefixSpecificity::Category,
+            CheckCodePrefix::RUF0 => PrefixSpecificity::Hundreds,
+            CheckCodePrefix::RUF00 => PrefixSpecificity::Tens,
+            CheckCodePrefix::RUF001 => PrefixSpecificity::Explicit,
+            CheckCodePrefix::RUF002 => PrefixSpecificity::Explicit,
             CheckCodePrefix::T => PrefixSpecificity::Category,
             CheckCodePrefix::T2 => PrefixSpecificity::Hundreds,
             CheckCodePrefix::T20 => PrefixSpecificity::Tens,
@@ -1106,6 +1234,7 @@ impl CheckCodePrefix {
             CheckCodePrefix::U006 => PrefixSpecificity::Explicit,
             CheckCodePrefix::U007 => PrefixSpecificity::Explicit,
             CheckCodePrefix::U008 => PrefixSpecificity::Explicit,
+            CheckCodePrefix::U009 => PrefixSpecificity::Explicit,
             CheckCodePrefix::W => PrefixSpecificity::Category,
             CheckCodePrefix::W2 => PrefixSpecificity::Hundreds,
             CheckCodePrefix::W29 => PrefixSpecificity::Tens,

src/cli.rs

@@ -10,7 +10,7 @@ use crate::checks_gen::CheckCodePrefix;
 use crate::logging::LogLevel;
 use crate::printer::SerializationFormat;
 use crate::settings::configuration::Configuration;
-use crate::settings::types::{PatternPrefixPair, PythonVersion};
+use crate::settings::types::{PatternPrefixPair, PerFileIgnore, PythonVersion};
 
 #[derive(Debug, Parser)]
 #[command(author, about = "ruff: An extremely fast Python linter.")]
@@ -38,8 +38,10 @@ pub struct Cli {
     #[arg(short, long)]
     pub watch: bool,
     /// Attempt to automatically fix lint errors.
-    #[arg(short, long)]
-    pub fix: bool,
+    #[arg(long, overrides_with("no_fix"))]
+    fix: bool,
+    #[clap(long, overrides_with("fix"), hide = true)]
+    no_fix: bool,
     /// Disable cache reads.
     #[arg(short, long)]
     pub no_cache: bool,
@@ -94,6 +96,22 @@ pub struct Cli {
     pub stdin_filename: Option<String>,
 }
 
+impl Cli {
+    // See: https://github.com/clap-rs/clap/issues/3146
+    pub fn fix(&self) -> Option<bool> {
+        resolve_bool_arg(self.fix, self.no_fix)
+    }
+}
+
+fn resolve_bool_arg(yes: bool, no: bool) -> Option<bool> {
+    match (yes, no) {
+        (true, false) => Some(true),
+        (false, true) => Some(false),
+        (false, false) => None,
+        (..) => unreachable!("Clap should make this impossible"),
+    }
+}
+
 /// Map the CLI settings to a `LogLevel`.
 pub fn extract_log_level(cli: &Cli) -> LogLevel {
     if cli.silent {
@@ -165,10 +183,11 @@ pub fn warn_on(
     }
 }
 
-/// Collect a list of `PatternPrefixPair` structs as a `BTreeMap`.
+/// Convert a list of `PatternPrefixPair` structs to `PerFileIgnore`.
 pub fn collect_per_file_ignores(
     pairs: Vec<PatternPrefixPair>,
-) -> BTreeMap<String, Vec<CheckCodePrefix>> {
+    project_root: &Option<PathBuf>,
+) -> Vec<PerFileIgnore> {
     let mut per_file_ignores: BTreeMap<String, Vec<CheckCodePrefix>> = BTreeMap::new();
     for pair in pairs {
         per_file_ignores
@@ -177,4 +196,7 @@ pub fn collect_per_file_ignores(
             .push(pair.prefix);
     }
     per_file_ignores
+        .iter()
+        .map(|(pattern, prefixes)| PerFileIgnore::new(pattern, prefixes, project_root))
+        .collect()
 }

src/cst/matchers.rs

@@ -1,19 +1,21 @@
 use anyhow::Result;
-use libcst_native::Module;
-use rustpython_ast::Located;
+use libcst_native::{Expr, Module, SmallStatement, Statement};
 
-use crate::ast::types::Range;
-use crate::source_code_locator::SourceCodeLocator;
-
-pub fn match_tree<'a, T>(
-    locator: &'a SourceCodeLocator,
-    located: &'a Located<T>,
-) -> Result<Module<'a>> {
-    match libcst_native::parse_module(
-        locator.slice_source_code_range(&Range::from_located(located)),
-        None,
-    ) {
+pub fn match_module(module_text: &str) -> Result<Module> {
+    match libcst_native::parse_module(module_text, None) {
         Ok(module) => Ok(module),
-        Err(_) => return Err(anyhow::anyhow!("Failed to extract CST from source.")),
+        Err(_) => Err(anyhow::anyhow!("Failed to extract CST from source.")),
+    }
+}
+
+pub fn match_expr<'a, 'b>(module: &'a mut Module<'b>) -> Result<&'a mut Expr<'b>> {
+    if let Some(Statement::Simple(expr)) = module.body.first_mut() {
+        if let Some(SmallStatement::Expr(expr)) = expr.body.first_mut() {
+            Ok(expr)
+        } else {
+            Err(anyhow::anyhow!("Expected node to be: SmallStatement::Expr"))
+        }
+    } else {
+        Err(anyhow::anyhow!("Expected node to be: Statement::Simple"))
     }
 }

src/docstrings/helpers.rs

@@ -25,12 +25,15 @@ pub fn leading_space(line: &str) -> String {
 }
 
 /// Extract the leading indentation from a docstring.
-pub fn indentation<'a>(checker: &'a Checker, docstring: &Expr) -> &'a str {
+pub fn indentation<'a>(checker: &'a Checker, docstring: &Expr) -> String {
     let range = Range::from_located(docstring);
-    checker.locator.slice_source_code_range(&Range {
-        location: Location::new(range.location.row(), 0),
-        end_location: Location::new(range.location.row(), range.location.column()),
-    })
+    checker
+        .locator
+        .slice_source_code_range(&Range {
+            location: Location::new(range.location.row(), 0),
+            end_location: Location::new(range.location.row(), range.location.column()),
+        })
+        .to_string()
 }
 
 /// Replace any non-whitespace characters from an indentation string.

src/flake8_annotations/mod.rs

@@ -0,0 +1,131 @@
+pub mod plugins;
+pub mod settings;
+
+#[cfg(test)]
+mod tests {
+    use std::path::Path;
+
+    use anyhow::Result;
+    use rustpython_parser::lexer::LexResult;
+
+    use crate::autofix::fixer;
+    use crate::checks::{Check, CheckCode};
+    use crate::linter::tokenize;
+    use crate::{flake8_annotations, fs, linter, noqa, Settings, SourceCodeLocator};
+
+    fn check_path(path: &Path, settings: &Settings, autofix: &fixer::Mode) -> Result<Vec<Check>> {
+        let contents = fs::read_file(path)?;
+        let tokens: Vec<LexResult> = tokenize(&contents);
+        let locator = SourceCodeLocator::new(&contents);
+        let noqa_line_for = noqa::extract_noqa_line_for(&tokens);
+        linter::check_path(
+            path,
+            &contents,
+            tokens,
+            &locator,
+            &noqa_line_for,
+            settings,
+            autofix,
+        )
+    }
+
+    #[test]
+    fn defaults() -> Result<()> {
+        let mut checks = check_path(
+            Path::new("./resources/test/fixtures/flake8_annotations/annotation_presence.py"),
+            &Settings {
+                ..Settings::for_rules(vec![
+                    CheckCode::ANN001,
+                    CheckCode::ANN002,
+                    CheckCode::ANN003,
+                    CheckCode::ANN101,
+                    CheckCode::ANN102,
+                    CheckCode::ANN201,
+                    CheckCode::ANN202,
+                    CheckCode::ANN204,
+                    CheckCode::ANN205,
+                    CheckCode::ANN206,
+                ])
+            },
+            &fixer::Mode::Generate,
+        )?;
+        checks.sort_by_key(|check| check.location);
+        insta::assert_yaml_snapshot!(checks);
+        Ok(())
+    }
+
+    #[test]
+    fn suppress_dummy_args() -> Result<()> {
+        let mut checks = check_path(
+            Path::new("./resources/test/fixtures/flake8_annotations/suppress_dummy_args.py"),
+            &Settings {
+                flake8_annotations: flake8_annotations::settings::Settings {
+                    mypy_init_return: false,
+                    suppress_dummy_args: true,
+                    suppress_none_returning: false,
+                },
+                ..Settings::for_rules(vec![
+                    CheckCode::ANN001,
+                    CheckCode::ANN002,
+                    CheckCode::ANN003,
+                    CheckCode::ANN101,
+                    CheckCode::ANN102,
+                ])
+            },
+            &fixer::Mode::Generate,
+        )?;
+        checks.sort_by_key(|check| check.location);
+        insta::assert_yaml_snapshot!(checks);
+        Ok(())
+    }
+
+    #[test]
+    fn mypy_init_return() -> Result<()> {
+        let mut checks = check_path(
+            Path::new("./resources/test/fixtures/flake8_annotations/mypy_init_return.py"),
+            &Settings {
+                flake8_annotations: flake8_annotations::settings::Settings {
+                    mypy_init_return: true,
+                    suppress_dummy_args: false,
+                    suppress_none_returning: false,
+                },
+                ..Settings::for_rules(vec![
+                    CheckCode::ANN201,
+                    CheckCode::ANN202,
+                    CheckCode::ANN204,
+                    CheckCode::ANN205,
+                    CheckCode::ANN206,
+                ])
+            },
+            &fixer::Mode::Generate,
+        )?;
+        checks.sort_by_key(|check| check.location);
+        insta::assert_yaml_snapshot!(checks);
+        Ok(())
+    }
+
+    #[test]
+    fn suppress_none_returning() -> Result<()> {
+        let mut checks = check_path(
+            Path::new("./resources/test/fixtures/flake8_annotations/suppress_none_returning.py"),
+            &Settings {
+                flake8_annotations: flake8_annotations::settings::Settings {
+                    mypy_init_return: false,
+                    suppress_dummy_args: false,
+                    suppress_none_returning: true,
+                },
+                ..Settings::for_rules(vec![
+                    CheckCode::ANN201,
+                    CheckCode::ANN202,
+                    CheckCode::ANN204,
+                    CheckCode::ANN205,
+                    CheckCode::ANN206,
+                ])
+            },
+            &fixer::Mode::Generate,
+        )?;
+        checks.sort_by_key(|check| check.location);
+        insta::assert_yaml_snapshot!(checks);
+        Ok(())
+    }
+}

src/flake8_annotations/plugins.rs

@@ -0,0 +1,324 @@
+use rustpython_ast::{Arguments, Constant, Expr, ExprKind, Stmt, StmtKind};
+
+use crate::ast::types::Range;
+use crate::ast::visitor;
+use crate::ast::visitor::Visitor;
+use crate::check_ast::Checker;
+use crate::checks::{CheckCode, CheckKind};
+use crate::docstrings::definition::{Definition, DefinitionKind};
+use crate::visibility::Visibility;
+use crate::{visibility, Check};
+
+#[derive(Default)]
+struct ReturnStatementVisitor<'a> {
+    returns: Vec<&'a Option<Box<Expr>>>,
+}
+
+impl<'a, 'b> Visitor<'b> for ReturnStatementVisitor<'a>
+where
+    'b: 'a,
+{
+    fn visit_stmt(&mut self, stmt: &'b Stmt) {
+        match &stmt.node {
+            StmtKind::FunctionDef { .. } | StmtKind::AsyncFunctionDef { .. } => {
+                // No recurse.
+            }
+            StmtKind::Return { value } => self.returns.push(value),
+            _ => visitor::walk_stmt(self, stmt),
+        }
+    }
+}
+
+fn is_none_returning(body: &[Stmt]) -> bool {
+    let mut visitor: ReturnStatementVisitor = Default::default();
+    for stmt in body {
+        visitor.visit_stmt(stmt);
+    }
+    for expr in visitor.returns.into_iter().flatten() {
+        if !matches!(
+            expr.node,
+            ExprKind::Constant {
+                value: Constant::None,
+                ..
+            }
+        ) {
+            return false;
+        }
+    }
+    true
+}
+
+fn match_function_def(stmt: &Stmt) -> (&str, &Arguments, &Option<Box<Expr>>, &Vec<Stmt>) {
+    match &stmt.node {
+        StmtKind::FunctionDef {
+            name,
+            args,
+            returns,
+            body,
+            ..
+        }
+        | StmtKind::AsyncFunctionDef {
+            name,
+            args,
+            returns,
+            body,
+            ..
+        } => (name, args, returns, body),
+        _ => panic!("Found non-FunctionDef in match_name"),
+    }
+}
+
+/// Generate flake8-annotation checks for a given `Definition`.
+pub fn definition(checker: &mut Checker, definition: &Definition, visibility: &Visibility) {
+    // TODO(charlie): Consider using the AST directly here rather than `Definition`.
+    // We could adhere more closely to `flake8-annotations` by defining public
+    // vs. secret vs. protected.
+    match &definition.kind {
+        DefinitionKind::Module => {}
+        DefinitionKind::Package => {}
+        DefinitionKind::Class(_) => {}
+        DefinitionKind::NestedClass(_) => {}
+        DefinitionKind::Function(stmt) | DefinitionKind::NestedFunction(stmt) => {
+            let (name, args, returns, body) = match_function_def(stmt);
+
+            // ANN001
+            for arg in args
+                .args
+                .iter()
+                .chain(args.posonlyargs.iter())
+                .chain(args.kwonlyargs.iter())
+            {
+                if arg.node.annotation.is_none() {
+                    if !(checker.settings.flake8_annotations.suppress_dummy_args
+                        && checker.settings.dummy_variable_rgx.is_match(&arg.node.arg))
+                    {
+                        if checker.settings.enabled.contains(&CheckCode::ANN001) {
+                            checker.add_check(Check::new(
+                                CheckKind::MissingTypeFunctionArgument(arg.node.arg.to_string()),
+                                Range::from_located(arg),
+                            ));
+                        }
+                    }
+                }
+            }
+
+            // ANN002
+            if let Some(arg) = &args.vararg {
+                if arg.node.annotation.is_none() {
+                    if !(checker.settings.flake8_annotations.suppress_dummy_args
+                        && checker.settings.dummy_variable_rgx.is_match(&arg.node.arg))
+                    {
+                        if checker.settings.enabled.contains(&CheckCode::ANN002) {
+                            checker.add_check(Check::new(
+                                CheckKind::MissingTypeArgs(arg.node.arg.to_string()),
+                                Range::from_located(arg),
+                            ));
+                        }
+                    }
+                }
+            }
+
+            // ANN003
+            if let Some(arg) = &args.kwarg {
+                if arg.node.annotation.is_none() {
+                    if !(checker.settings.flake8_annotations.suppress_dummy_args
+                        && checker.settings.dummy_variable_rgx.is_match(&arg.node.arg))
+                    {
+                        if checker.settings.enabled.contains(&CheckCode::ANN003) {
+                            checker.add_check(Check::new(
+                                CheckKind::MissingTypeKwargs(arg.node.arg.to_string()),
+                                Range::from_located(arg),
+                            ));
+                        }
+                    }
+                }
+            }
+
+            // ANN201, ANN202
+            if returns.is_none() {
+                // Allow omission of return annotation in `__init__` functions, if the function
+                // only returns `None` (explicitly or implicitly).
+                if checker.settings.flake8_annotations.suppress_none_returning
+                    && is_none_returning(body)
+                {
+                    return;
+                }
+
+                match visibility {
+                    Visibility::Public => {
+                        if checker.settings.enabled.contains(&CheckCode::ANN201) {
+                            checker.add_check(Check::new(
+                                CheckKind::MissingReturnTypePublicFunction(name.to_string()),
+                                Range::from_located(stmt),
+                            ));
+                        }
+                    }
+                    Visibility::Private => {
+                        if checker.settings.enabled.contains(&CheckCode::ANN202) {
+                            checker.add_check(Check::new(
+                                CheckKind::MissingReturnTypePrivateFunction(name.to_string()),
+                                Range::from_located(stmt),
+                            ));
+                        }
+                    }
+                }
+            }
+        }
+        DefinitionKind::Method(stmt) => {
+            let (name, args, returns, body) = match_function_def(stmt);
+            let mut has_any_typed_arg = false;
+
+            // ANN001
+            for arg in args
+                .args
+                .iter()
+                .chain(args.posonlyargs.iter())
+                .chain(args.kwonlyargs.iter())
+                .skip(
+                    // If this is a non-static method, skip `cls` or `self`.
+                    usize::from(!visibility::is_staticmethod(stmt)),
+                )
+            {
+                if arg.node.annotation.is_none() {
+                    if !(checker.settings.flake8_annotations.suppress_dummy_args
+                        && checker.settings.dummy_variable_rgx.is_match(&arg.node.arg))
+                    {
+                        if checker.settings.enabled.contains(&CheckCode::ANN001) {
+                            checker.add_check(Check::new(
+                                CheckKind::MissingTypeFunctionArgument(arg.node.arg.to_string()),
+                                Range::from_located(arg),
+                            ));
+                        }
+                    }
+                } else {
+                    has_any_typed_arg = true;
+                }
+            }
+
+            // ANN002
+            if let Some(arg) = &args.vararg {
+                if arg.node.annotation.is_none() {
+                    if !(checker.settings.flake8_annotations.suppress_dummy_args
+                        && checker.settings.dummy_variable_rgx.is_match(&arg.node.arg))
+                    {
+                        if checker.settings.enabled.contains(&CheckCode::ANN002) {
+                            checker.add_check(Check::new(
+                                CheckKind::MissingTypeArgs(arg.node.arg.to_string()),
+                                Range::from_located(arg),
+                            ));
+                        }
+                    }
+                } else {
+                    has_any_typed_arg = true;
+                }
+            }
+
+            // ANN003
+            if let Some(arg) = &args.kwarg {
+                if arg.node.annotation.is_none() {
+                    if !(checker.settings.flake8_annotations.suppress_dummy_args
+                        && checker.settings.dummy_variable_rgx.is_match(&arg.node.arg))
+                    {
+                        if checker.settings.enabled.contains(&CheckCode::ANN003) {
+                            checker.add_check(Check::new(
+                                CheckKind::MissingTypeKwargs(arg.node.arg.to_string()),
+                                Range::from_located(arg),
+                            ));
+                        }
+                    }
+                } else {
+                    has_any_typed_arg = true;
+                }
+            }
+
+            // ANN101, ANN102
+            if !visibility::is_staticmethod(stmt) {
+                if let Some(arg) = args.args.first() {
+                    if arg.node.annotation.is_none() {
+                        if visibility::is_classmethod(stmt) {
+                            if checker.settings.enabled.contains(&CheckCode::ANN102) {
+                                checker.add_check(Check::new(
+                                    CheckKind::MissingTypeCls(arg.node.arg.to_string()),
+                                    Range::from_located(arg),
+                                ));
+                            }
+                        } else {
+                            if checker.settings.enabled.contains(&CheckCode::ANN101) {
+                                checker.add_check(Check::new(
+                                    CheckKind::MissingTypeSelf(arg.node.arg.to_string()),
+                                    Range::from_located(arg),
+                                ));
+                            }
+                        }
+                    }
+                }
+            }
+
+            // ANN201, ANN202
+            if returns.is_none() {
+                // Allow omission of return annotation in `__init__` functions, if the function
+                // only returns `None` (explicitly or implicitly).
+                if checker.settings.flake8_annotations.suppress_none_returning
+                    && is_none_returning(body)
+                {
+                    return;
+                }
+
+                if visibility::is_classmethod(stmt) {
+                    if checker.settings.enabled.contains(&CheckCode::ANN206) {
+                        checker.add_check(Check::new(
+                            CheckKind::MissingReturnTypeClassMethod(name.to_string()),
+                            Range::from_located(stmt),
+                        ));
+                    }
+                } else if visibility::is_staticmethod(stmt) {
+                    if checker.settings.enabled.contains(&CheckCode::ANN205) {
+                        checker.add_check(Check::new(
+                            CheckKind::MissingReturnTypeStaticMethod(name.to_string()),
+                            Range::from_located(stmt),
+                        ));
+                    }
+                } else if visibility::is_magic(stmt) {
+                    if checker.settings.enabled.contains(&CheckCode::ANN204) {
+                        checker.add_check(Check::new(
+                            CheckKind::MissingReturnTypeMagicMethod(name.to_string()),
+                            Range::from_located(stmt),
+                        ));
+                    }
+                } else if visibility::is_init(stmt) {
+                    // Allow omission of return annotation in `__init__` functions, as long as at
+                    // least one argument is typed.
+                    if checker.settings.enabled.contains(&CheckCode::ANN204) {
+                        if !(checker.settings.flake8_annotations.mypy_init_return
+                            && has_any_typed_arg)
+                        {
+                            checker.add_check(Check::new(
+                                CheckKind::MissingReturnTypeMagicMethod(name.to_string()),
+                                Range::from_located(stmt),
+                            ));
+                        }
+                    }
+                } else {
+                    match visibility {
+                        Visibility::Public => {
+                            if checker.settings.enabled.contains(&CheckCode::ANN201) {
+                                checker.add_check(Check::new(
+                                    CheckKind::MissingReturnTypePublicFunction(name.to_string()),
+                                    Range::from_located(stmt),
+                                ));
+                            }
+                        }
+                        Visibility::Private => {
+                            if checker.settings.enabled.contains(&CheckCode::ANN202) {
+                                checker.add_check(Check::new(
+                                    CheckKind::MissingReturnTypePrivateFunction(name.to_string()),
+                                    Range::from_located(stmt),
+                                ));
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}

src/flake8_annotations/settings.rs

@@ -0,0 +1,36 @@
+//! Settings for the `flake-annotations` plugin.
+
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, PartialEq, Eq, Serialize, Deserialize, Default)]
+#[serde(deny_unknown_fields, rename_all = "kebab-case")]
+pub struct Options {
+    /// Allow omission of a return type hint for `__init__` if at least one
+    /// argument is annotated.
+    pub mypy_init_return: Option<bool>,
+    /// Suppress ANN000-level errors for dummy arguments, like `_`.
+    pub suppress_dummy_args: Option<bool>,
+    /// Suppress ANN200-level errors for functions that meet one of the
+    /// following criteria:
+    /// - Contain no `return` statement
+    /// - Explicit `return` statement(s) all return `None` (explicitly or
+    ///   implicitly).
+    pub suppress_none_returning: Option<bool>,
+}
+
+#[derive(Debug, Hash, Default)]
+pub struct Settings {
+    pub mypy_init_return: bool,
+    pub suppress_dummy_args: bool,
+    pub suppress_none_returning: bool,
+}
+
+impl Settings {
+    pub fn from_options(options: Options) -> Self {
+        Self {
+            mypy_init_return: options.mypy_init_return.unwrap_or_default(),
+            suppress_dummy_args: options.suppress_dummy_args.unwrap_or_default(),
+            suppress_none_returning: options.suppress_none_returning.unwrap_or_default(),
+        }
+    }
+}

src/flake8_annotations/snapshots/ruff__flake8_annotations__tests__defaults.snap

@@ -0,0 +1,95 @@
+---
+source: src/flake8_annotations/mod.rs
+expression: checks
+---
+- kind:
+    MissingReturnTypePublicFunction: foo
+  location:
+    row: 4
+    column: 0
+  end_location:
+    row: 9
+    column: 0
+  fix: ~
+- kind:
+    MissingTypeFunctionArgument: a
+  location:
+    row: 4
+    column: 8
+  end_location:
+    row: 4
+    column: 9
+  fix: ~
+- kind:
+    MissingTypeFunctionArgument: b
+  location:
+    row: 4
+    column: 11
+  end_location:
+    row: 4
+    column: 12
+  fix: ~
+- kind:
+    MissingReturnTypePublicFunction: foo
+  location:
+    row: 9
+    column: 0
+  end_location:
+    row: 14
+    column: 0
+  fix: ~
+- kind:
+    MissingTypeFunctionArgument: b
+  location:
+    row: 9
+    column: 16
+  end_location:
+    row: 9
+    column: 17
+  fix: ~
+- kind:
+    MissingTypeFunctionArgument: b
+  location:
+    row: 14
+    column: 16
+  end_location:
+    row: 14
+    column: 17
+  fix: ~
+- kind:
+    MissingReturnTypePublicFunction: foo
+  location:
+    row: 19
+    column: 0
+  end_location:
+    row: 24
+    column: 0
+  fix: ~
+- kind:
+    MissingReturnTypePublicFunction: foo
+  location:
+    row: 24
+    column: 0
+  end_location:
+    row: 29
+    column: 0
+  fix: ~
+- kind:
+    MissingTypeSelf: self
+  location:
+    row: 44
+    column: 12
+  end_location:
+    row: 44
+    column: 16
+  fix: ~
+- kind:
+    MissingTypeCls: cls
+  location:
+    row: 54
+    column: 12
+  end_location:
+    row: 54
+    column: 15
+  fix: ~
+

src/flake8_annotations/snapshots/ruff__flake8_annotations__tests__mypy_init_return.snap

@@ -0,0 +1,32 @@
+---
+source: src/flake8_annotations/mod.rs
+expression: checks
+---
+- kind:
+    MissingReturnTypeMagicMethod: __init__
+  location:
+    row: 5
+    column: 4
+  end_location:
+    row: 10
+    column: 0
+  fix: ~
+- kind:
+    MissingReturnTypeMagicMethod: __init__
+  location:
+    row: 11
+    column: 4
+  end_location:
+    row: 16
+    column: 0
+  fix: ~
+- kind:
+    MissingReturnTypePrivateFunction: __init__
+  location:
+    row: 40
+    column: 0
+  end_location:
+    row: 42
+    column: 0
+  fix: ~
+

src/flake8_annotations/snapshots/ruff__flake8_annotations__tests__suppress_dummy_args.snap

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

src/flake8_annotations/snapshots/ruff__flake8_annotations__tests__suppress_none_returning.snap

@@ -0,0 +1,23 @@
+---
+source: src/flake8_annotations/mod.rs
+expression: checks
+---
+- kind:
+    MissingReturnTypePublicFunction: foo
+  location:
+    row: 45
+    column: 0
+  end_location:
+    row: 50
+    column: 0
+  fix: ~
+- kind:
+    MissingReturnTypePublicFunction: foo
+  location:
+    row: 50
+    column: 0
+  end_location:
+    row: 56
+    column: 0
+  fix: ~
+

src/flake8_bugbear/plugins/assert_false.rs

@@ -1,6 +1,6 @@
 use rustpython_ast::{Constant, Expr, ExprContext, ExprKind, Stmt, StmtKind};
 
-use crate::ast::types::{CheckLocator, Range};
+use crate::ast::types::Range;
 use crate::autofix::Fix;
 use crate::check_ast::Checker;
 use crate::checks::{Check, CheckKind};
@@ -42,10 +42,7 @@ pub fn assert_false(checker: &mut Checker, stmt: &Stmt, test: &Expr, msg: &Optio
         ..
     } = &test.node
     {
-        let mut check = Check::new(
-            CheckKind::DoNotAssertFalse,
-            checker.locate_check(Range::from_located(test)),
-        );
+        let mut check = Check::new(CheckKind::DoNotAssertFalse, Range::from_located(test));
         if checker.patch() {
             let mut generator = SourceGenerator::new();
             if let Ok(()) = generator.unparse_stmt(&assertion_error(msg)) {

src/flake8_bugbear/plugins/assert_raises_exception.rs

@@ -1,7 +1,7 @@
 use rustpython_ast::{ExprKind, Stmt, Withitem};
 
 use crate::ast::helpers::match_name_or_attr;
-use crate::ast::types::{CheckLocator, Range};
+use crate::ast::types::Range;
 use crate::check_ast::Checker;
 use crate::checks::{Check, CheckKind};
 
@@ -17,7 +17,7 @@ pub fn assert_raises_exception(checker: &mut Checker, stmt: &Stmt, items: &[With
             {
                 checker.add_check(Check::new(
                     CheckKind::NoAssertRaisesException,
-                    checker.locate_check(Range::from_located(stmt)),
+                    Range::from_located(stmt),
                 ));
             }
         }

src/flake8_bugbear/plugins/assignment_to_os_environ.rs

@@ -0,0 +1,24 @@
+use rustpython_ast::{Expr, ExprKind};
+
+use crate::ast::types::Range;
+use crate::check_ast::Checker;
+use crate::checks::{Check, CheckKind};
+
+/// B003
+pub fn assignment_to_os_environ(checker: &mut Checker, targets: &[Expr]) {
+    if targets.len() == 1 {
+        let target = &targets[0];
+        if let ExprKind::Attribute { value, attr, .. } = &target.node {
+            if attr == "environ" {
+                if let ExprKind::Name { id, .. } = &value.node {
+                    if id == "os" {
+                        checker.add_check(Check::new(
+                            CheckKind::AssignmentToOsEnviron,
+                            Range::from_located(target),
+                        ));
+                    }
+                }
+            }
+        }
+    }
+}

src/flake8_bugbear/plugins/cannot_raise_literal.rs

@@ -0,0 +1,15 @@
+use rustpython_ast::{Expr, ExprKind};
+
+use crate::ast::types::Range;
+use crate::check_ast::Checker;
+use crate::checks::{Check, CheckKind};
+
+/// B016
+pub fn cannot_raise_literal(checker: &mut Checker, expr: &Expr) {
+    if let ExprKind::Constant { .. } = &expr.node {
+        checker.add_check(Check::new(
+            CheckKind::CannotRaiseLiteral,
+            Range::from_located(expr),
+        ));
+    }
+}

src/flake8_bugbear/plugins/duplicate_exceptions.rs

@@ -4,7 +4,7 @@ use itertools::Itertools;
 use rustpython_ast::{Excepthandler, ExcepthandlerKind, Expr, ExprContext, ExprKind, Stmt};
 
 use crate::ast::helpers;
-use crate::ast::types::{CheckLocator, Range};
+use crate::ast::types::Range;
 use crate::autofix::Fix;
 use crate::check_ast::Checker;
 use crate::checks::{Check, CheckCode, CheckKind};
@@ -47,7 +47,7 @@ pub fn duplicate_handler_exceptions(
                 CheckKind::DuplicateHandlerException(
                     duplicates.into_iter().sorted().collect::<Vec<String>>(),
                 ),
-                checker.locate_check(Range::from_located(expr)),
+                Range::from_located(expr),
             );
             if checker.patch() {
                 // TODO(charlie): If we have a single element, remove the tuple.
@@ -106,7 +106,7 @@ pub fn duplicate_exceptions(checker: &mut Checker, stmt: &Stmt, handlers: &[Exce
         for duplicate in duplicates.into_iter().sorted() {
             checker.add_check(Check::new(
                 CheckKind::DuplicateTryBlockException(duplicate),
-                checker.locate_check(Range::from_located(stmt)),
+                Range::from_located(stmt),
             ));
         }
     }

src/flake8_bugbear/plugins/function_call_argument_default.rs

@@ -0,0 +1,96 @@
+use rustpython_ast::{Arguments, Constant, Expr, ExprKind};
+
+use crate::ast::helpers::compose_call_path;
+use crate::ast::types::Range;
+use crate::ast::visitor;
+use crate::ast::visitor::Visitor;
+use crate::check_ast::Checker;
+use crate::checks::{Check, CheckKind};
+use crate::flake8_bugbear::plugins::mutable_argument_default::is_mutable_func;
+
+const IMMUTABLE_FUNCS: [&str; 11] = [
+    "tuple",
+    "frozenset",
+    "operator.attrgetter",
+    "operator.itemgetter",
+    "operator.methodcaller",
+    "attrgetter",
+    "itemgetter",
+    "methodcaller",
+    "types.MappingProxyType",
+    "MappingProxyType",
+    "re.compile",
+];
+
+fn is_immutable_func(expr: &Expr) -> bool {
+    compose_call_path(expr).map_or_else(|| false, |func| IMMUTABLE_FUNCS.contains(&func.as_str()))
+}
+
+struct ArgumentDefaultVisitor {
+    checks: Vec<(CheckKind, Range)>,
+}
+
+impl<'a, 'b> Visitor<'b> for ArgumentDefaultVisitor
+where
+    'b: 'a,
+{
+    fn visit_expr(&mut self, expr: &'a Expr) {
+        match &expr.node {
+            ExprKind::Call { func, args, .. } => {
+                if !is_mutable_func(func)
+                    && !is_immutable_func(func)
+                    && !is_nan_or_infinity(func, args)
+                {
+                    self.checks.push((
+                        CheckKind::FunctionCallArgumentDefault,
+                        Range::from_located(expr),
+                    ))
+                }
+                visitor::walk_expr(self, expr)
+            }
+            ExprKind::Lambda { .. } => {}
+            _ => visitor::walk_expr(self, expr),
+        }
+    }
+}
+
+fn is_nan_or_infinity(expr: &Expr, args: &[Expr]) -> bool {
+    if let ExprKind::Name { id, .. } = &expr.node {
+        if id == "float" {
+            if let Some(arg) = args.first() {
+                if let ExprKind::Constant {
+                    value: Constant::Str(value),
+                    ..
+                } = &arg.node
+                {
+                    let lowercased = value.to_lowercase();
+                    return lowercased == "nan"
+                        || lowercased == "+nan"
+                        || lowercased == "-nan"
+                        || lowercased == "inf"
+                        || lowercased == "+inf"
+                        || lowercased == "-inf"
+                        || lowercased == "infinity"
+                        || lowercased == "+infinity"
+                        || lowercased == "-infinity";
+                }
+            }
+        }
+    }
+    false
+}
+
+/// B008
+pub fn function_call_argument_default(checker: &mut Checker, arguments: &Arguments) {
+    let mut visitor = ArgumentDefaultVisitor { checks: vec![] };
+    for expr in arguments
+        .defaults
+        .iter()
+        .chain(arguments.kw_defaults.iter())
+    {
+        visitor.visit_expr(expr);
+    }
+    for (check, range) in visitor.checks {
+        checker.add_check(Check::new(check, range));
+    }
+}

src/flake8_bugbear/plugins/mod.rs

@@ -1,15 +1,29 @@
 pub use assert_false::assert_false;
 pub use assert_raises_exception::assert_raises_exception;
+pub use assignment_to_os_environ::assignment_to_os_environ;
+pub use cannot_raise_literal::cannot_raise_literal;
 pub use duplicate_exceptions::{duplicate_exceptions, duplicate_handler_exceptions};
+pub use function_call_argument_default::function_call_argument_default;
 pub use mutable_argument_default::mutable_argument_default;
 pub use redundant_tuple_in_exception_handler::redundant_tuple_in_exception_handler;
+pub use strip_with_multi_characters::strip_with_multi_characters;
 pub use unary_prefix_increment::unary_prefix_increment;
+pub use unreliable_callable_check::unreliable_callable_check;
 pub use unused_loop_control_variable::unused_loop_control_variable;
+pub use useless_comparison::useless_comparison;
+pub use useless_expression::useless_expression;
 
 mod assert_false;
 mod assert_raises_exception;
+mod assignment_to_os_environ;
+mod cannot_raise_literal;
 mod duplicate_exceptions;
+mod function_call_argument_default;
 mod mutable_argument_default;
 mod redundant_tuple_in_exception_handler;
+mod strip_with_multi_characters;
 mod unary_prefix_increment;
+mod unreliable_callable_check;
 mod unused_loop_control_variable;
+mod useless_comparison;
+mod useless_expression;

src/flake8_bugbear/plugins/mutable_argument_default.rs

@@ -1,9 +1,34 @@
-use rustpython_ast::{Arguments, ExprKind};
+use rustpython_ast::{Arguments, Expr, ExprKind};
 
-use crate::ast::types::{CheckLocator, Range};
+use crate::ast::types::Range;
 use crate::check_ast::Checker;
 use crate::checks::{Check, CheckKind};
 
+pub fn is_mutable_func(expr: &Expr) -> bool {
+    match &expr.node {
+        ExprKind::Name { id, .. }
+            if id == "dict"
+                || id == "list"
+                || id == "set"
+                || id == "Counter"
+                || id == "OrderedDict"
+                || id == "defaultdict"
+                || id == "deque" =>
+        {
+            true
+        }
+        ExprKind::Attribute { value, attr, .. }
+            if (attr == "Counter"
+                || attr == "OrderedDict"
+                || attr == "defaultdict"
+                || attr == "deque") =>
+        {
+            matches!(&value.node, ExprKind::Name { id, .. } if id == "collections")
+        }
+        _ => false,
+    }
+}
+
 /// B006
 pub fn mutable_argument_default(checker: &mut Checker, arguments: &Arguments) {
     for expr in arguments
@@ -20,42 +45,17 @@ pub fn mutable_argument_default(checker: &mut Checker, arguments: &Arguments) {
             | ExprKind::SetComp { .. } => {
                 checker.add_check(Check::new(
                     CheckKind::MutableArgumentDefault,
-                    checker.locate_check(Range::from_located(expr)),
+                    Range::from_located(expr),
                 ));
             }
-            ExprKind::Call { func, .. } => match &func.node {
-                ExprKind::Name { id, .. }
-                    if id == "dict"
-                        || id == "list"
-                        || id == "set"
-                        || id == "Counter"
-                        || id == "OrderedDict"
-                        || id == "defaultdict"
-                        || id == "deque" =>
-                {
+            ExprKind::Call { func, .. } => {
+                if is_mutable_func(func) {
                     checker.add_check(Check::new(
                         CheckKind::MutableArgumentDefault,
-                        checker.locate_check(Range::from_located(expr)),
+                        Range::from_located(expr),
                     ));
                 }
-                ExprKind::Attribute { value, attr, .. }
-                    if (attr == "Counter"
-                        || attr == "OrderedDict"
-                        || attr == "defaultdict"
-                        || attr == "deque") =>
-                {
-                    match &value.node {
-                        ExprKind::Name { id, .. } if id == "collections" => {
-                            checker.add_check(Check::new(
-                                CheckKind::MutableArgumentDefault,
-                                checker.locate_check(Range::from_located(expr)),
-                            ));
-                        }
-                        _ => {}
-                    }
-                }
-                _ => {}
-            },
+            }
             _ => {}
         }
     }

src/flake8_bugbear/plugins/redundant_tuple_in_exception_handler.rs

@@ -1,6 +1,6 @@
 use rustpython_ast::{Excepthandler, ExcepthandlerKind, ExprKind};
 
-use crate::ast::types::{CheckLocator, Range};
+use crate::ast::types::Range;
 use crate::check_ast::Checker;
 use crate::checks::{Check, CheckKind};
 
@@ -13,7 +13,7 @@ pub fn redundant_tuple_in_exception_handler(checker: &mut Checker, handlers: &[E
                 if elts.len() == 1 {
                     checker.add_check(Check::new(
                         CheckKind::RedundantTupleInExceptionHandler(elts[0].to_string()),
-                        checker.locate_check(Range::from_located(type_)),
+                        Range::from_located(type_),
                     ));
                 }
             }

src/flake8_bugbear/plugins/strip_with_multi_characters.rs

@@ -0,0 +1,28 @@
+use itertools::Itertools;
+use rustpython_ast::{Constant, Expr, ExprKind};
+
+use crate::ast::types::Range;
+use crate::check_ast::Checker;
+use crate::checks::{Check, CheckKind};
+
+/// B005
+pub fn strip_with_multi_characters(checker: &mut Checker, expr: &Expr, func: &Expr, args: &[Expr]) {
+    if let ExprKind::Attribute { attr, .. } = &func.node {
+        if attr == "strip" || attr == "lstrip" || attr == "rstrip" {
+            if args.len() == 1 {
+                if let ExprKind::Constant {
+                    value: Constant::Str(value),
+                    ..
+                } = &args[0].node
+                {
+                    if value.len() > 1 && value.chars().unique().count() != value.len() {
+                        checker.add_check(Check::new(
+                            CheckKind::StripWithMultiCharacters,
+                            Range::from_located(expr),
+                        ));
+                    }
+                }
+            }
+        }
+    }
+}

src/flake8_bugbear/plugins/unary_prefix_increment.rs

@@ -1,6 +1,6 @@
 use rustpython_ast::{Expr, ExprKind, Unaryop};
 
-use crate::ast::types::{CheckLocator, Range};
+use crate::ast::types::Range;
 use crate::check_ast::Checker;
 use crate::checks::{Check, CheckKind};
 
@@ -11,7 +11,7 @@ pub fn unary_prefix_increment(checker: &mut Checker, expr: &Expr, op: &Unaryop,
             if matches!(op, Unaryop::UAdd) {
                 checker.add_check(Check::new(
                     CheckKind::UnaryPrefixIncrement,
-                    checker.locate_check(Range::from_located(expr)),
+                    Range::from_located(expr),
                 ))
             }
         }

src/flake8_bugbear/plugins/unreliable_callable_check.rs

@@ -0,0 +1,27 @@
+use rustpython_ast::{Constant, Expr, ExprKind};
+
+use crate::ast::types::Range;
+use crate::check_ast::Checker;
+use crate::checks::{Check, CheckKind};
+
+/// B004
+pub fn unreliable_callable_check(checker: &mut Checker, expr: &Expr, func: &Expr, args: &[Expr]) {
+    if let ExprKind::Name { id, .. } = &func.node {
+        if id == "getattr" || id == "hasattr" {
+            if args.len() >= 2 {
+                if let ExprKind::Constant {
+                    value: Constant::Str(s),
+                    ..
+                } = &args[1].node
+                {
+                    if s == "__call__" {
+                        checker.add_check(Check::new(
+                            CheckKind::UnreliableCallableCheck,
+                            Range::from_located(expr),
+                        ));
+                    }
+                }
+            }
+        }
+    }
+}

src/flake8_bugbear/plugins/unused_loop_control_variable.rs

@@ -2,7 +2,7 @@ use std::collections::BTreeMap;
 
 use rustpython_ast::{Expr, ExprKind, Stmt};
 
-use crate::ast::types::{CheckLocator, Range};
+use crate::ast::types::Range;
 use crate::ast::visitor;
 use crate::ast::visitor::Visitor;
 use crate::autofix::Fix;
@@ -64,7 +64,7 @@ pub fn unused_loop_control_variable(checker: &mut Checker, target: &Expr, body:
 
         let mut check = Check::new(
             CheckKind::UnusedLoopControlVariable(name.to_string()),
-            checker.locate_check(Range::from_located(expr)),
+            Range::from_located(expr),
         );
         if checker.patch() {
             // Prefix the variable name with an underscore.

src/flake8_bugbear/plugins/useless_comparison.rs

@@ -0,0 +1,14 @@
+use rustpython_ast::{Expr, ExprKind};
+
+use crate::ast::types::Range;
+use crate::check_ast::Checker;
+use crate::checks::{Check, CheckKind};
+
+pub fn useless_comparison(checker: &mut Checker, expr: &Expr) {
+    if let ExprKind::Compare { left, .. } = &expr.node {
+        checker.add_check(Check::new(
+            CheckKind::UselessComparison,
+            Range::from_located(left),
+        ));
+    }
+}

src/flake8_bugbear/plugins/useless_expression.rs

@@ -0,0 +1,31 @@
+use rustpython_ast::{Constant, ExprKind, Stmt, StmtKind};
+
+use crate::ast::types::Range;
+use crate::check_ast::Checker;
+use crate::checks::{Check, CheckKind};
+
+// B018
+pub fn useless_expression(checker: &mut Checker, body: &[Stmt]) {
+    for stmt in body {
+        if let StmtKind::Expr { value } = &stmt.node {
+            match &value.node {
+                ExprKind::List { .. } | ExprKind::Dict { .. } | ExprKind::Set { .. } => {
+                    checker.add_check(Check::new(
+                        CheckKind::UselessExpression,
+                        Range::from_located(value),
+                    ));
+                }
+                ExprKind::Constant { value: val, .. } => match &val {
+                    Constant::Str { .. } | Constant::Ellipsis => {}
+                    _ => {
+                        checker.add_check(Check::new(
+                            CheckKind::UselessExpression,
+                            Range::from_located(value),
+                        ));
+                    }
+                },
+                _ => {}
+            }
+        }
+    }
+}

src/flake8_comprehensions/fixes.rs

@@ -1,27 +1,15 @@
 use anyhow::Result;
 use libcst_native::{
     Arg, Call, Codegen, Dict, DictComp, DictElement, Element, Expr, Expression, LeftCurlyBrace,
-    LeftParen, LeftSquareBracket, List, ListComp, Module, Name, ParenthesizableWhitespace,
-    RightCurlyBrace, RightParen, RightSquareBracket, Set, SetComp, SimpleString, SimpleWhitespace,
-    SmallStatement, Statement, Tuple,
+    LeftParen, LeftSquareBracket, List, ListComp, Name, ParenthesizableWhitespace, RightCurlyBrace,
+    RightParen, RightSquareBracket, Set, SetComp, SimpleString, SimpleWhitespace, Tuple,
 };
 
+use crate::ast::types::Range;
 use crate::autofix::Fix;
-use crate::cst::matchers::match_tree;
+use crate::cst::matchers::{match_expr, match_module};
 use crate::source_code_locator::SourceCodeLocator;
 
-fn match_expr<'a, 'b>(module: &'a mut Module<'b>) -> Result<&'a mut Expr<'b>> {
-    if let Some(Statement::Simple(expr)) = module.body.first_mut() {
-        if let Some(SmallStatement::Expr(expr)) = expr.body.first_mut() {
-            Ok(expr)
-        } else {
-            Err(anyhow::anyhow!("Expected node to be: SmallStatement::Expr"))
-        }
-    } else {
-        Err(anyhow::anyhow!("Expected node to be: Statement::Simple"))
-    }
-}
-
 fn match_call<'a, 'b>(expr: &'a mut Expr<'b>) -> Result<&'a mut Call<'b>> {
     if let Expression::Call(call) = &mut expr.value {
         Ok(call)
@@ -44,7 +32,8 @@ pub fn fix_unnecessary_generator_list(
     expr: &rustpython_ast::Expr,
 ) -> Result<Fix> {
     // Expr(Call(GeneratorExp)))) -> Expr(ListComp)))
-    let mut tree = match_tree(locator, expr)?;
+    let module_text = locator.slice_source_code_range(&Range::from_located(expr));
+    let mut tree = match_module(&module_text)?;
     let mut body = match_expr(&mut tree)?;
     let call = match_call(body)?;
     let arg = match_arg(call)?;
@@ -86,7 +75,8 @@ pub fn fix_unnecessary_generator_set(
     expr: &rustpython_ast::Expr,
 ) -> Result<Fix> {
     // Expr(Call(GeneratorExp)))) -> Expr(SetComp)))
-    let mut tree = match_tree(locator, expr)?;
+    let module_text = locator.slice_source_code_range(&Range::from_located(expr));
+    let mut tree = match_module(&module_text)?;
     let mut body = match_expr(&mut tree)?;
     let call = match_call(body)?;
     let arg = match_arg(call)?;
@@ -128,7 +118,8 @@ pub fn fix_unnecessary_generator_dict(
     locator: &SourceCodeLocator,
     expr: &rustpython_ast::Expr,
 ) -> Result<Fix> {
-    let mut tree = match_tree(locator, expr)?;
+    let module_text = locator.slice_source_code_range(&Range::from_located(expr));
+    let mut tree = match_module(&module_text)?;
     let mut body = match_expr(&mut tree)?;
     let call = match_call(body)?;
     let arg = match_arg(call)?;
@@ -194,7 +185,8 @@ pub fn fix_unnecessary_list_comprehension_set(
 ) -> Result<Fix> {
     // Expr(Call(ListComp)))) ->
     // Expr(SetComp)))
-    let mut tree = match_tree(locator, expr)?;
+    let module_text = locator.slice_source_code_range(&Range::from_located(expr));
+    let mut tree = match_module(&module_text)?;
     let mut body = match_expr(&mut tree)?;
     let call = match_call(body)?;
     let arg = match_arg(call)?;
@@ -234,7 +226,8 @@ pub fn fix_unnecessary_literal_set(
     expr: &rustpython_ast::Expr,
 ) -> Result<Fix> {
     // Expr(Call(List|Tuple)))) -> Expr(Set)))
-    let mut tree = match_tree(locator, expr)?;
+    let module_text = locator.slice_source_code_range(&Range::from_located(expr));
+    let mut tree = match_module(&module_text)?;
     let mut body = match_expr(&mut tree)?;
     let mut call = match_call(body)?;
     let arg = match_arg(call)?;
@@ -281,7 +274,8 @@ pub fn fix_unnecessary_literal_dict(
     expr: &rustpython_ast::Expr,
 ) -> Result<Fix> {
     // Expr(Call(List|Tuple)))) -> Expr(Dict)))
-    let mut tree = match_tree(locator, expr)?;
+    let module_text = locator.slice_source_code_range(&Range::from_located(expr));
+    let mut tree = match_module(&module_text)?;
     let mut body = match_expr(&mut tree)?;
     let call = match_call(body)?;
     let arg = match_arg(call)?;
@@ -351,8 +345,9 @@ pub fn fix_unnecessary_collection_call(
     locator: &SourceCodeLocator,
     expr: &rustpython_ast::Expr,
 ) -> Result<Fix> {
-    // Expr(Call("list" | "tuple" | "dict")))) -> Expr(List|Tuple|Dict)))
-    let mut tree = match_tree(locator, expr)?;
+    // Expr(Call("list" | "tuple" | "dict")))) -> Expr(List|Tuple|Dict)
+    let module_text = locator.slice_source_code_range(&Range::from_located(expr));
+    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() {
@@ -463,7 +458,8 @@ pub fn fix_unnecessary_literal_within_tuple_call(
     locator: &SourceCodeLocator,
     expr: &rustpython_ast::Expr,
 ) -> Result<Fix> {
-    let mut tree = match_tree(locator, expr)?;
+    let module_text = locator.slice_source_code_range(&Range::from_located(expr));
+    let mut tree = match_module(&module_text)?;
     let mut body = match_expr(&mut tree)?;
     let call = match_call(body)?;
     let arg = match_arg(call)?;
@@ -518,7 +514,8 @@ pub fn fix_unnecessary_literal_within_list_call(
     locator: &SourceCodeLocator,
     expr: &rustpython_ast::Expr,
 ) -> Result<Fix> {
-    let mut tree = match_tree(locator, expr)?;
+    let module_text = locator.slice_source_code_range(&Range::from_located(expr));
+    let mut tree = match_module(&module_text)?;
     let mut body = match_expr(&mut tree)?;
     let call = match_call(body)?;
     let arg = match_arg(call)?;
@@ -576,7 +573,8 @@ pub fn fix_unnecessary_list_call(
     expr: &rustpython_ast::Expr,
 ) -> Result<Fix> {
     // Expr(Call(List|Tuple)))) -> Expr(List|Tuple)))
-    let mut tree = match_tree(locator, expr)?;
+    let module_text = locator.slice_source_code_range(&Range::from_located(expr));
+    let mut tree = match_module(&module_text)?;
     let mut body = match_expr(&mut tree)?;
     let call = match_call(body)?;
     let arg = match_arg(call)?;
@@ -598,7 +596,8 @@ pub fn fix_unnecessary_comprehension(
     locator: &SourceCodeLocator,
     expr: &rustpython_ast::Expr,
 ) -> Result<Fix> {
-    let mut tree = match_tree(locator, expr)?;
+    let module_text = locator.slice_source_code_range(&Range::from_located(expr));
+    let mut tree = match_module(&module_text)?;
     let mut body = match_expr(&mut tree)?;
 
     match &body.value {

src/flake8_print/plugins/print_call.rs

@@ -1,7 +1,7 @@
 use log::error;
 use rustpython_ast::{Expr, Stmt, StmtKind};
 
-use crate::ast::types::{CheckLocator, Range};
+use crate::ast::types::Range;
 use crate::autofix::helpers;
 use crate::check_ast::Checker;
 use crate::checks::CheckCode;
@@ -13,7 +13,7 @@ pub fn print_call(checker: &mut Checker, expr: &Expr, func: &Expr) {
         func,
         checker.settings.enabled.contains(&CheckCode::T201),
         checker.settings.enabled.contains(&CheckCode::T203),
-        checker.locate_check(Range::from_located(expr)),
+        Range::from_located(expr),
     ) {
         if checker.patch() {
             let context = checker.binding_context();

src/flake8_quotes/checks.rs

@@ -135,163 +135,3 @@ pub fn quotes(
 
     None
 }
-
-#[cfg(test)]
-mod tests {
-    use std::path::Path;
-
-    use anyhow::Result;
-    use rustpython_parser::lexer::LexResult;
-    use test_case::test_case;
-
-    use crate::autofix::fixer;
-    use crate::checks::{Check, CheckCode};
-    use crate::flake8_quotes::settings::Quote;
-    use crate::linter::tokenize;
-    use crate::{flake8_quotes, fs, linter, noqa, Settings};
-
-    fn check_path(path: &Path, settings: &Settings, autofix: &fixer::Mode) -> Result<Vec<Check>> {
-        let contents = fs::read_file(path)?;
-        let tokens: Vec<LexResult> = tokenize(&contents);
-        let noqa_line_for = noqa::extract_noqa_line_for(&tokens);
-        linter::check_path(path, &contents, tokens, &noqa_line_for, settings, autofix)
-    }
-
-    #[test_case(Path::new("doubles.py"))]
-    #[test_case(Path::new("doubles_escaped.py"))]
-    #[test_case(Path::new("doubles_multiline_string.py"))]
-    #[test_case(Path::new("doubles_noqa.py"))]
-    #[test_case(Path::new("doubles_wrapped.py"))]
-    fn doubles(path: &Path) -> Result<()> {
-        let snapshot = format!("doubles_{}", path.to_string_lossy());
-        let mut checks = check_path(
-            Path::new("./resources/test/fixtures/flake8_quotes")
-                .join(path)
-                .as_path(),
-            &Settings {
-                flake8_quotes: flake8_quotes::settings::Settings {
-                    inline_quotes: Quote::Single,
-                    multiline_quotes: Quote::Single,
-                    docstring_quotes: Quote::Single,
-                    avoid_escape: true,
-                },
-                ..Settings::for_rules(vec![
-                    CheckCode::Q000,
-                    CheckCode::Q001,
-                    CheckCode::Q002,
-                    CheckCode::Q003,
-                ])
-            },
-            &fixer::Mode::Generate,
-        )?;
-        checks.sort_by_key(|check| check.location);
-        insta::assert_yaml_snapshot!(snapshot, checks);
-        Ok(())
-    }
-
-    #[test_case(Path::new("singles.py"))]
-    #[test_case(Path::new("singles_escaped.py"))]
-    #[test_case(Path::new("singles_multiline_string.py"))]
-    #[test_case(Path::new("singles_noqa.py"))]
-    #[test_case(Path::new("singles_wrapped.py"))]
-    fn singles(path: &Path) -> Result<()> {
-        let snapshot = format!("singles_{}", path.to_string_lossy());
-        let mut checks = check_path(
-            Path::new("./resources/test/fixtures/flake8_quotes")
-                .join(path)
-                .as_path(),
-            &Settings {
-                flake8_quotes: flake8_quotes::settings::Settings {
-                    inline_quotes: Quote::Double,
-                    multiline_quotes: Quote::Double,
-                    docstring_quotes: Quote::Double,
-                    avoid_escape: true,
-                },
-                ..Settings::for_rules(vec![
-                    CheckCode::Q000,
-                    CheckCode::Q001,
-                    CheckCode::Q002,
-                    CheckCode::Q003,
-                ])
-            },
-            &fixer::Mode::Generate,
-        )?;
-        checks.sort_by_key(|check| check.location);
-        insta::assert_yaml_snapshot!(snapshot, checks);
-        Ok(())
-    }
-
-    #[test_case(Path::new("docstring_doubles.py"))]
-    #[test_case(Path::new("docstring_doubles_module_multiline.py"))]
-    #[test_case(Path::new("docstring_doubles_module_singleline.py"))]
-    #[test_case(Path::new("docstring_doubles_class.py"))]
-    #[test_case(Path::new("docstring_doubles_function.py"))]
-    #[test_case(Path::new("docstring_singles.py"))]
-    #[test_case(Path::new("docstring_singles_module_multiline.py"))]
-    #[test_case(Path::new("docstring_singles_module_singleline.py"))]
-    #[test_case(Path::new("docstring_singles_class.py"))]
-    #[test_case(Path::new("docstring_singles_function.py"))]
-    fn double_docstring(path: &Path) -> Result<()> {
-        let snapshot = format!("double_docstring_{}", path.to_string_lossy());
-        let mut checks = check_path(
-            Path::new("./resources/test/fixtures/flake8_quotes")
-                .join(path)
-                .as_path(),
-            &Settings {
-                flake8_quotes: flake8_quotes::settings::Settings {
-                    inline_quotes: Quote::Single,
-                    multiline_quotes: Quote::Single,
-                    docstring_quotes: Quote::Double,
-                    avoid_escape: true,
-                },
-                ..Settings::for_rules(vec![
-                    CheckCode::Q000,
-                    CheckCode::Q001,
-                    CheckCode::Q002,
-                    CheckCode::Q003,
-                ])
-            },
-            &fixer::Mode::Generate,
-        )?;
-        checks.sort_by_key(|check| check.location);
-        insta::assert_yaml_snapshot!(snapshot, checks);
-        Ok(())
-    }
-
-    #[test_case(Path::new("docstring_doubles.py"))]
-    #[test_case(Path::new("docstring_doubles_module_multiline.py"))]
-    #[test_case(Path::new("docstring_doubles_module_singleline.py"))]
-    #[test_case(Path::new("docstring_doubles_class.py"))]
-    #[test_case(Path::new("docstring_doubles_function.py"))]
-    #[test_case(Path::new("docstring_singles.py"))]
-    #[test_case(Path::new("docstring_singles_module_multiline.py"))]
-    #[test_case(Path::new("docstring_singles_module_singleline.py"))]
-    #[test_case(Path::new("docstring_singles_class.py"))]
-    #[test_case(Path::new("docstring_singles_function.py"))]
-    fn single_docstring(path: &Path) -> Result<()> {
-        let snapshot = format!("single_docstring_{}", path.to_string_lossy());
-        let mut checks = check_path(
-            Path::new("./resources/test/fixtures/flake8_quotes")
-                .join(path)
-                .as_path(),
-            &Settings {
-                flake8_quotes: flake8_quotes::settings::Settings {
-                    inline_quotes: Quote::Single,
-                    multiline_quotes: Quote::Double,
-                    docstring_quotes: Quote::Single,
-                    avoid_escape: true,
-                },
-                ..Settings::for_rules(vec![
-                    CheckCode::Q000,
-                    CheckCode::Q001,
-                    CheckCode::Q002,
-                    CheckCode::Q003,
-                ])
-            },
-            &fixer::Mode::Generate,
-        )?;
-        checks.sort_by_key(|check| check.location);
-        insta::assert_yaml_snapshot!(snapshot, checks);
-        Ok(())
-    }
-}

src/flake8_quotes/mod.rs

@@ -1,3 +1,171 @@
 pub mod checks;
-pub mod docstring_detection;
 pub mod settings;
+
+#[cfg(test)]
+mod tests {
+    use std::path::Path;
+
+    use anyhow::Result;
+    use rustpython_parser::lexer::LexResult;
+    use test_case::test_case;
+
+    use crate::autofix::fixer;
+    use crate::checks::{Check, CheckCode};
+    use crate::flake8_quotes::settings::Quote;
+    use crate::linter::tokenize;
+    use crate::{flake8_quotes, fs, linter, noqa, Settings, SourceCodeLocator};
+
+    fn check_path(path: &Path, settings: &Settings, autofix: &fixer::Mode) -> Result<Vec<Check>> {
+        let contents = fs::read_file(path)?;
+        let tokens: Vec<LexResult> = tokenize(&contents);
+        let locator = SourceCodeLocator::new(&contents);
+        let noqa_line_for = noqa::extract_noqa_line_for(&tokens);
+        linter::check_path(
+            path,
+            &contents,
+            tokens,
+            &locator,
+            &noqa_line_for,
+            settings,
+            autofix,
+        )
+    }
+
+    #[test_case(Path::new("doubles.py"))]
+    #[test_case(Path::new("doubles_escaped.py"))]
+    #[test_case(Path::new("doubles_multiline_string.py"))]
+    #[test_case(Path::new("doubles_noqa.py"))]
+    #[test_case(Path::new("doubles_wrapped.py"))]
+    fn doubles(path: &Path) -> Result<()> {
+        let snapshot = format!("doubles_{}", path.to_string_lossy());
+        let mut checks = check_path(
+            Path::new("./resources/test/fixtures/flake8_quotes")
+                .join(path)
+                .as_path(),
+            &Settings {
+                flake8_quotes: flake8_quotes::settings::Settings {
+                    inline_quotes: Quote::Single,
+                    multiline_quotes: Quote::Single,
+                    docstring_quotes: Quote::Single,
+                    avoid_escape: true,
+                },
+                ..Settings::for_rules(vec![
+                    CheckCode::Q000,
+                    CheckCode::Q001,
+                    CheckCode::Q002,
+                    CheckCode::Q003,
+                ])
+            },
+            &fixer::Mode::Generate,
+        )?;
+        checks.sort_by_key(|check| check.location);
+        insta::assert_yaml_snapshot!(snapshot, checks);
+        Ok(())
+    }
+
+    #[test_case(Path::new("singles.py"))]
+    #[test_case(Path::new("singles_escaped.py"))]
+    #[test_case(Path::new("singles_multiline_string.py"))]
+    #[test_case(Path::new("singles_noqa.py"))]
+    #[test_case(Path::new("singles_wrapped.py"))]
+    fn singles(path: &Path) -> Result<()> {
+        let snapshot = format!("singles_{}", path.to_string_lossy());
+        let mut checks = check_path(
+            Path::new("./resources/test/fixtures/flake8_quotes")
+                .join(path)
+                .as_path(),
+            &Settings {
+                flake8_quotes: flake8_quotes::settings::Settings {
+                    inline_quotes: Quote::Double,
+                    multiline_quotes: Quote::Double,
+                    docstring_quotes: Quote::Double,
+                    avoid_escape: true,
+                },
+                ..Settings::for_rules(vec![
+                    CheckCode::Q000,
+                    CheckCode::Q001,
+                    CheckCode::Q002,
+                    CheckCode::Q003,
+                ])
+            },
+            &fixer::Mode::Generate,
+        )?;
+        checks.sort_by_key(|check| check.location);
+        insta::assert_yaml_snapshot!(snapshot, checks);
+        Ok(())
+    }
+
+    #[test_case(Path::new("docstring_doubles.py"))]
+    #[test_case(Path::new("docstring_doubles_module_multiline.py"))]
+    #[test_case(Path::new("docstring_doubles_module_singleline.py"))]
+    #[test_case(Path::new("docstring_doubles_class.py"))]
+    #[test_case(Path::new("docstring_doubles_function.py"))]
+    #[test_case(Path::new("docstring_singles.py"))]
+    #[test_case(Path::new("docstring_singles_module_multiline.py"))]
+    #[test_case(Path::new("docstring_singles_module_singleline.py"))]
+    #[test_case(Path::new("docstring_singles_class.py"))]
+    #[test_case(Path::new("docstring_singles_function.py"))]
+    fn double_docstring(path: &Path) -> Result<()> {
+        let snapshot = format!("double_docstring_{}", path.to_string_lossy());
+        let mut checks = check_path(
+            Path::new("./resources/test/fixtures/flake8_quotes")
+                .join(path)
+                .as_path(),
+            &Settings {
+                flake8_quotes: flake8_quotes::settings::Settings {
+                    inline_quotes: Quote::Single,
+                    multiline_quotes: Quote::Single,
+                    docstring_quotes: Quote::Double,
+                    avoid_escape: true,
+                },
+                ..Settings::for_rules(vec![
+                    CheckCode::Q000,
+                    CheckCode::Q001,
+                    CheckCode::Q002,
+                    CheckCode::Q003,
+                ])
+            },
+            &fixer::Mode::Generate,
+        )?;
+        checks.sort_by_key(|check| check.location);
+        insta::assert_yaml_snapshot!(snapshot, checks);
+        Ok(())
+    }
+
+    #[test_case(Path::new("docstring_doubles.py"))]
+    #[test_case(Path::new("docstring_doubles_module_multiline.py"))]
+    #[test_case(Path::new("docstring_doubles_module_singleline.py"))]
+    #[test_case(Path::new("docstring_doubles_class.py"))]
+    #[test_case(Path::new("docstring_doubles_function.py"))]
+    #[test_case(Path::new("docstring_singles.py"))]
+    #[test_case(Path::new("docstring_singles_module_multiline.py"))]
+    #[test_case(Path::new("docstring_singles_module_singleline.py"))]
+    #[test_case(Path::new("docstring_singles_class.py"))]
+    #[test_case(Path::new("docstring_singles_function.py"))]
+    fn single_docstring(path: &Path) -> Result<()> {
+        let snapshot = format!("single_docstring_{}", path.to_string_lossy());
+        let mut checks = check_path(
+            Path::new("./resources/test/fixtures/flake8_quotes")
+                .join(path)
+                .as_path(),
+            &Settings {
+                flake8_quotes: flake8_quotes::settings::Settings {
+                    inline_quotes: Quote::Single,
+                    multiline_quotes: Quote::Double,
+                    docstring_quotes: Quote::Single,
+                    avoid_escape: true,
+                },
+                ..Settings::for_rules(vec![
+                    CheckCode::Q000,
+                    CheckCode::Q001,
+                    CheckCode::Q002,
+                    CheckCode::Q003,
+                ])
+            },
+            &fixer::Mode::Generate,
+        )?;
+        checks.sort_by_key(|check| check.location);
+        insta::assert_yaml_snapshot!(snapshot, checks);
+        Ok(())
+    }
+}

src/flake8_quotes/snapshots/ruff__flake8_quotes__tests__double_docstring_docstring_doubles.py.snap

@@ -0,0 +1,50 @@
+---
+source: src/flake8_quotes/mod.rs
+expression: checks
+---
+- kind:
+    BadQuotesMultilineString: single
+  location:
+    row: 5
+    column: 0
+  end_location:
+    row: 7
+    column: 3
+  fix: ~
+- kind:
+    BadQuotesMultilineString: single
+  location:
+    row: 16
+    column: 4
+  end_location:
+    row: 18
+    column: 7
+  fix: ~
+- kind:
+    BadQuotesMultilineString: single
+  location:
+    row: 21
+    column: 20
+  end_location:
+    row: 22
+    column: 37
+  fix: ~
+- kind:
+    BadQuotesMultilineString: single
+  location:
+    row: 30
+    column: 8
+  end_location:
+    row: 32
+    column: 11
+  fix: ~
+- kind:
+    BadQuotesMultilineString: single
+  location:
+    row: 35
+    column: 12
+  end_location:
+    row: 37
+    column: 15
+  fix: ~
+

src/flake8_quotes/snapshots/ruff__flake8_quotes__tests__double_docstring_docstring_doubles_class.py.snap

@@ -0,0 +1,23 @@
+---
+source: src/flake8_quotes/mod.rs
+expression: checks
+---
+- kind:
+    BadQuotesMultilineString: single
+  location:
+    row: 3
+    column: 4
+  end_location:
+    row: 3
+    column: 27
+  fix: ~
+- kind:
+    BadQuotesMultilineString: single
+  location:
+    row: 5
+    column: 22
+  end_location:
+    row: 5
+    column: 43
+  fix: ~
+

src/flake8_quotes/snapshots/ruff__flake8_quotes__tests__double_docstring_docstring_doubles_function.py.snap

@@ -0,0 +1,50 @@
+---
+source: src/flake8_quotes/mod.rs
+expression: checks
+---
+- kind:
+    BadQuotesMultilineString: single
+  location:
+    row: 3
+    column: 4
+  end_location:
+    row: 3
+    column: 26
+  fix: ~
+- kind:
+    BadQuotesMultilineString: single
+  location:
+    row: 11
+    column: 4
+  end_location:
+    row: 11
+    column: 26
+  fix: ~
+- kind:
+    BadQuotesMultilineString: single
+  location:
+    row: 15
+    column: 38
+  end_location:
+    row: 17
+    column: 3
+  fix: ~
+- kind:
+    BadQuotesMultilineString: single
+  location:
+    row: 17
+    column: 4
+  end_location:
+    row: 17
+    column: 19
+  fix: ~
+- kind:
+    BadQuotesMultilineString: single
+  location:
+    row: 21
+    column: 4
+  end_location:
+    row: 21
+    column: 27
+  fix: ~
+

src/flake8_quotes/snapshots/ruff__flake8_quotes__tests__double_docstring_docstring_doubles_module_multiline.py.snap

@@ -0,0 +1,23 @@
+---
+source: src/flake8_quotes/mod.rs
+expression: checks
+---
+- kind:
+    BadQuotesMultilineString: single
+  location:
+    row: 4
+    column: 0
+  end_location:
+    row: 6
+    column: 3
+  fix: ~
+- kind:
+    BadQuotesMultilineString: single
+  location:
+    row: 9
+    column: 0
+  end_location:
+    row: 11
+    column: 3
+  fix: ~
+

src/flake8_quotes/snapshots/ruff__flake8_quotes__tests__double_docstring_docstring_doubles_module_singleline.py.snap

@@ -0,0 +1,23 @@
+---
+source: src/flake8_quotes/mod.rs
+expression: checks
+---
+- kind:
+    BadQuotesMultilineString: single
+  location:
+    row: 2
+    column: 0
+  end_location:
+    row: 2
+    column: 31
+  fix: ~
+- kind:
+    BadQuotesMultilineString: single
+  location:
+    row: 6
+    column: 0
+  end_location:
+    row: 6
+    column: 31
+  fix: ~
+

src/flake8_quotes/snapshots/ruff__flake8_quotes__tests__double_docstring_docstring_singles.py.snap

@@ -0,0 +1,32 @@
+---
+source: src/flake8_quotes/mod.rs
+expression: checks
+---
+- kind:
+    BadQuotesDocstring: double
+  location:
+    row: 1
+    column: 0
+  end_location:
+    row: 3
+    column: 3
+  fix: ~
+- kind:
+    BadQuotesDocstring: double
+  location:
+    row: 14
+    column: 4
+  end_location:
+    row: 16
+    column: 7
+  fix: ~
+- kind:
+    BadQuotesDocstring: double
+  location:
+    row: 26
+    column: 8
+  end_location:
+    row: 28
+    column: 11
+  fix: ~
+

src/flake8_quotes/snapshots/ruff__flake8_quotes__tests__double_docstring_docstring_singles_class.py.snap

@@ -0,0 +1,32 @@
+---
+source: src/flake8_quotes/mod.rs
+expression: checks
+---
+- kind:
+    BadQuotesDocstring: double
+  location:
+    row: 2
+    column: 4
+  end_location:
+    row: 2
+    column: 53
+  fix: ~
+- kind:
+    BadQuotesDocstring: double
+  location:
+    row: 6
+    column: 8
+  end_location:
+    row: 6
+    column: 57
+  fix: ~
+- kind:
+    BadQuotesDocstring: double
+  location:
+    row: 9
+    column: 28
+  end_location:
+    row: 9
+    column: 52
+  fix: ~
+

src/flake8_quotes/snapshots/ruff__flake8_quotes__tests__double_docstring_docstring_singles_function.py.snap

@@ -0,0 +1,23 @@
+---
+source: src/flake8_quotes/mod.rs
+expression: checks
+---
+- kind:
+    BadQuotesDocstring: double
+  location:
+    row: 2
+    column: 4
+  end_location:
+    row: 2
+    column: 56
+  fix: ~
+- kind:
+    BadQuotesDocstring: double
+  location:
+    row: 8
+    column: 4
+  end_location:
+    row: 10
+    column: 7
+  fix: ~
+

src/flake8_quotes/snapshots/ruff__flake8_quotes__tests__double_docstring_docstring_singles_module_multiline.py.snap

@@ -0,0 +1,14 @@
+---
+source: src/flake8_quotes/mod.rs
+expression: checks
+---
+- kind:
+    BadQuotesDocstring: double
+  location:
+    row: 1
+    column: 0
+  end_location:
+    row: 3
+    column: 3
+  fix: ~
+

src/flake8_quotes/snapshots/ruff__flake8_quotes__tests__double_docstring_docstring_singles_module_singleline.py.snap

@@ -0,0 +1,14 @@
+---
+source: src/flake8_quotes/mod.rs
+expression: checks
+---
+- kind:
+    BadQuotesDocstring: double
+  location:
+    row: 1
+    column: 0
+  end_location:
+    row: 1
+    column: 49
+  fix: ~
+

src/flake8_quotes/snapshots/ruff__flake8_quotes__tests__doubles_doubles.py.snap

@@ -0,0 +1,23 @@
+---
+source: src/flake8_quotes/mod.rs
+expression: checks
+---
+- kind:
+    BadQuotesInlineString: single
+  location:
+    row: 1
+    column: 24
+  end_location:
+    row: 1
+    column: 45
+  fix: ~
+- kind:
+    BadQuotesInlineString: single
+  location:
+    row: 2
+    column: 24
+  end_location:
+    row: 2
+    column: 46
+  fix: ~
+

src/flake8_quotes/snapshots/ruff__flake8_quotes__tests__doubles_doubles_escaped.py.snap

@@ -0,0 +1,13 @@
+---
+source: src/flake8_quotes/mod.rs
+expression: checks
+---
+- kind: AvoidQuoteEscape
+  location:
+    row: 1
+    column: 25
+  end_location:
+    row: 1
+    column: 47
+  fix: ~
+