Remove -dev suffix from flake8_to_ruff

Actually, it looks like _none_ of the existing rules should be triggered on async `with` statements.

Closes #1902.

.github/workflows/ci.yaml

@@ -80,6 +80,9 @@ jobs:
           cargo insta test --all --delete-unreferenced-snapshots
           git diff --exit-code
       - run: cargo test --package ruff_cli --test black_compatibility_test -- --ignored
+      # Check for broken links in the documentation.
+      # Setting RUSTDOCFLAGS because `cargo doc --check` isn't yet implemented (https://github.com/rust-lang/cargo/issues/10025).
+      - run: RUSTDOCFLAGS="-D warnings" cargo doc --all --no-deps
 
 # TODO(charlie): Re-enable the `wasm-pack` tests.
 # See: https://github.com/charliermarsh/ruff/issues/1425

.pre-commit-config.yaml

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

BREAKING_CHANGES.md

@@ -1,5 +1,20 @@
 # Breaking Changes
 
+## 0.0.222
+
+### `--max-complexity` has been removed from the CLI ([#1877](https://github.com/charliermarsh/ruff/pull/1877))
+
+The McCabe plugin's `--max-complexity` setting has been removed from the CLI, for consistency with
+the treatment of other, similar settings.
+
+To set the maximum complexity, use the `max-complexity` property in your `pyproject.toml` file,
+like so:
+
+```toml
+[tool.ruff.mccabe]
+max-complexity = 10
+```
+
 ## 0.0.181
 
 ### Files excluded by `.gitignore` are now ignored ([#1234](https://github.com/charliermarsh/ruff/pull/1234))

Cargo.lock

@@ -735,7 +735,7 @@ checksum = "0ce7134b9999ecaf8bcd65542e436736ef32ddca1b3e06094cb6ec5755203b80"
 
 [[package]]
 name = "flake8-to-ruff"
-version = "0.0.221-dev.0"
+version = "0.0.223"
 dependencies = [
  "anyhow",
  "clap 4.0.32",
@@ -1364,6 +1364,27 @@ dependencies = [
  "libc",
 ]
 
+[[package]]
+name = "num_enum"
+version = "0.5.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cf5395665662ef45796a4ff5486c5d41d29e0c09640af4c5f17fd94ee2c119c9"
+dependencies = [
+ "num_enum_derive",
+]
+
+[[package]]
+name = "num_enum_derive"
+version = "0.5.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3b0498641e53dd6ac1a4f22547548caa6864cc4933784319cd1775271c5a46ce"
+dependencies = [
+ "proc-macro-crate",
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
 [[package]]
 name = "once_cell"
 version = "1.17.0"
@@ -1621,6 +1642,17 @@ dependencies = [
  "termtree",
 ]
 
+[[package]]
+name = "proc-macro-crate"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eda0fc3b0fb7c975631757e14d9049da17374063edb6ebbcbc54d880d4fe94e9"
+dependencies = [
+ "once_cell",
+ "thiserror",
+ "toml",
+]
+
 [[package]]
 name = "proc-macro-error"
 version = "1.0.4"
@@ -1874,7 +1906,7 @@ dependencies = [
 
 [[package]]
 name = "ruff"
-version = "0.0.221"
+version = "0.0.223"
 dependencies = [
  "anyhow",
  "bitflags",
@@ -1926,7 +1958,7 @@ dependencies = [
 
 [[package]]
 name = "ruff_cli"
-version = "0.0.221"
+version = "0.0.223"
 dependencies = [
  "annotate-snippets 0.9.1",
  "anyhow",
@@ -1963,7 +1995,7 @@ dependencies = [
 
 [[package]]
 name = "ruff_dev"
-version = "0.0.221"
+version = "0.0.223"
 dependencies = [
  "anyhow",
  "clap 4.0.32",
@@ -1984,7 +2016,7 @@ dependencies = [
 
 [[package]]
 name = "ruff_macros"
-version = "0.0.221"
+version = "0.0.223"
 dependencies = [
  "once_cell",
  "proc-macro2",
@@ -2027,8 +2059,8 @@ dependencies = [
 
 [[package]]
 name = "rustpython-ast"
-version = "0.1.0"
-source = "git+https://github.com/RustPython/RustPython.git?rev=d532160333ffeb6dbeca2c2728c2391cd1e53b7f#d532160333ffeb6dbeca2c2728c2391cd1e53b7f"
+version = "0.2.0"
+source = "git+https://github.com/RustPython/RustPython.git?rev=acbc517b55406c76da83d7b2711941d8d3f65b87#acbc517b55406c76da83d7b2711941d8d3f65b87"
 dependencies = [
  "num-bigint",
  "rustpython-common",
@@ -2037,8 +2069,8 @@ dependencies = [
 
 [[package]]
 name = "rustpython-common"
-version = "0.0.0"
-source = "git+https://github.com/RustPython/RustPython.git?rev=d532160333ffeb6dbeca2c2728c2391cd1e53b7f#d532160333ffeb6dbeca2c2728c2391cd1e53b7f"
+version = "0.2.0"
+source = "git+https://github.com/RustPython/RustPython.git?rev=acbc517b55406c76da83d7b2711941d8d3f65b87#acbc517b55406c76da83d7b2711941d8d3f65b87"
 dependencies = [
  "ascii",
  "bitflags",
@@ -2062,8 +2094,8 @@ dependencies = [
 
 [[package]]
 name = "rustpython-compiler-core"
-version = "0.1.2"
-source = "git+https://github.com/RustPython/RustPython.git?rev=d532160333ffeb6dbeca2c2728c2391cd1e53b7f#d532160333ffeb6dbeca2c2728c2391cd1e53b7f"
+version = "0.2.0"
+source = "git+https://github.com/RustPython/RustPython.git?rev=acbc517b55406c76da83d7b2711941d8d3f65b87#acbc517b55406c76da83d7b2711941d8d3f65b87"
 dependencies = [
  "bincode",
  "bitflags",
@@ -2072,15 +2104,15 @@ dependencies = [
  "lz4_flex",
  "num-bigint",
  "num-complex",
+ "num_enum",
  "serde",
- "static_assertions",
  "thiserror",
 ]
 
 [[package]]
 name = "rustpython-parser"
-version = "0.1.2"
-source = "git+https://github.com/RustPython/RustPython.git?rev=d532160333ffeb6dbeca2c2728c2391cd1e53b7f#d532160333ffeb6dbeca2c2728c2391cd1e53b7f"
+version = "0.2.0"
+source = "git+https://github.com/RustPython/RustPython.git?rev=acbc517b55406c76da83d7b2711941d8d3f65b87#acbc517b55406c76da83d7b2711941d8d3f65b87"
 dependencies = [
  "ahash",
  "anyhow",
@@ -2518,6 +2550,15 @@ dependencies = [
  "regex",
 ]
 
+[[package]]
+name = "toml"
+version = "0.5.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1333c76748e868a4d9d1017b5ab53171dfd095f70c712fdb4653a406547f598f"
+dependencies = [
+ "serde",
+]
+
 [[package]]
 name = "toml_datetime"
 version = "0.5.0"

Cargo.toml

@@ -8,7 +8,7 @@ default-members = [".", "ruff_cli"]
 
 [package]
 name = "ruff"
-version = "0.0.221"
+version = "0.0.223"
 authors = ["Charlie Marsh <charlie.r.marsh@gmail.com>"]
 edition = "2021"
 rust-version = "1.65.0"
@@ -46,11 +46,11 @@ once_cell = { version = "1.16.0" }
 path-absolutize = { version = "3.0.14", features = ["once_cell_cache", "use_unix_paths_on_wasm"] }
 regex = { version = "1.6.0" }
 ropey = { version = "1.5.0", features = ["cr_lines", "simd"], default-features = false }
-ruff_macros = { version = "0.0.221", path = "ruff_macros" }
+ruff_macros = { version = "0.0.223", path = "ruff_macros" }
 rustc-hash = { version = "1.1.0" }
-rustpython-ast = { features = ["unparse"], git = "https://github.com/RustPython/RustPython.git", rev = "d532160333ffeb6dbeca2c2728c2391cd1e53b7f" }
-rustpython-common = { git = "https://github.com/RustPython/RustPython.git", rev = "d532160333ffeb6dbeca2c2728c2391cd1e53b7f" }
-rustpython-parser = { features = ["lalrpop"], git = "https://github.com/RustPython/RustPython.git", rev = "d532160333ffeb6dbeca2c2728c2391cd1e53b7f" }
+rustpython-ast = { features = ["unparse"], git = "https://github.com/RustPython/RustPython.git", rev = "acbc517b55406c76da83d7b2711941d8d3f65b87" }
+rustpython-common = { git = "https://github.com/RustPython/RustPython.git", rev = "acbc517b55406c76da83d7b2711941d8d3f65b87" }
+rustpython-parser = { features = ["lalrpop"], git = "https://github.com/RustPython/RustPython.git", rev = "acbc517b55406c76da83d7b2711941d8d3f65b87" }
 schemars = { version = "0.8.11" }
 semver = { version = "1.0.16" }
 serde = { version = "1.0.147", features = ["derive"] }

README.md

@@ -51,16 +51,18 @@ Ruff is extremely actively developed and used in major open-source projects like
 - [Apache Airflow](https://github.com/apache/airflow)
 - [Bokeh](https://github.com/bokeh/bokeh)
 - [Zulip](https://github.com/zulip/zulip)
+- [Dagster](https://github.com/dagster-io/dagster)
 - [Pydantic](https://github.com/pydantic/pydantic)
 - [Sphinx](https://github.com/sphinx-doc/sphinx)
 - [Hatch](https://github.com/pypa/hatch)
 - [Jupyter](https://github.com/jupyter-server/jupyter_server)
-- [Synapse](https://github.com/matrix-org/synapse)
+- [Synapse (Matrix)](https://github.com/matrix-org/synapse)
 - [Saleor](https://github.com/saleor/saleor)
 - [Polars](https://github.com/pola-rs/polars)
 - [Ibis](https://github.com/ibis-project/ibis)
 - [OpenBB](https://github.com/OpenBB-finance/OpenBBTerminal)
-- [`pyca/cryptography`](https://github.com/pyca/cryptography)
+- [Cryptography (PyCA)](https://github.com/pyca/cryptography)
+- [SnowCLI (Snowflake)](https://github.com/Snowflake-Labs/snowcli)
 
 Read the [launch blog post](https://notes.crmarsh.com/python-tooling-could-be-much-much-faster).
 
@@ -121,6 +123,7 @@ of [Conda](https://docs.conda.io/en/latest/):
    1. [pygrep-hooks (PGH)](#pygrep-hooks-pgh)
    1. [Pylint (PLC, PLE, PLR, PLW)](#pylint-plc-ple-plr-plw)
    1. [flake8-pie (PIE)](#flake8-pie-pie)
+   1. [flake8-commas (COM)](#flake8-commas-com)
    1. [Ruff-specific rules (RUF)](#ruff-specific-rules-ruf)<!-- End auto-generated table of contents. -->
 1. [Editor Integrations](#editor-integrations)
 1. [FAQ](#faq)
@@ -182,7 +185,7 @@ Ruff also works with [pre-commit](https://pre-commit.com):
 ```yaml
 - repo: https://github.com/charliermarsh/ruff-pre-commit
   # Ruff version.
-  rev: 'v0.0.221'
+  rev: 'v0.0.223'
   hooks:
     - id: ruff
       # Respect `exclude` and `extend-exclude` settings.
@@ -383,8 +386,6 @@ Options:
           The minimum Python version that should be supported
       --line-length <LINE_LENGTH>
           Set the line-length for length-associated rules and automatic formatting
-      --max-complexity <MAX_COMPLEXITY>
-          Maximum McCabe complexity allowed for a given function
       --add-noqa
           Enable automatic additions of `noqa` directives to failing lines
       --clean
@@ -581,6 +582,7 @@ For more, see [Pyflakes](https://pypi.org/project/pyflakes/2.5.0/) on PyPI.
 
 For more, see [pycodestyle](https://pypi.org/project/pycodestyle/2.9.1/) on PyPI.
 
+#### Error (E)
 | Code | Name | Message | Fix |
 | ---- | ---- | ------- | --- |
 | E401 | MultipleImportsOnOneLine | Multiple imports on one line |  |
@@ -598,6 +600,10 @@ For more, see [pycodestyle](https://pypi.org/project/pycodestyle/2.9.1/) on PyPI
 | E743 | AmbiguousFunctionName | Ambiguous function name: `...` |  |
 | E902 | IOError | IOError: `...` |  |
 | E999 | SyntaxError | SyntaxError: `...` |  |
+
+#### Warning (W)
+| Code | Name | Message | Fix |
+| ---- | ---- | ------- | --- |
 | W292 | NoNewLineAtEndOfFile | No newline at end of file | 🛠 |
 | W505 | DocLineTooLong | Doc line too long (89 > 88 characters) |  |
 | W605 | InvalidEscapeSequence | Invalid escape sequence: '\c' | 🛠 |
@@ -979,7 +985,6 @@ For more, see [flake8-simplify](https://pypi.org/project/flake8-simplify/0.19.3/
 
 | Code | Name | Message | Fix |
 | ---- | ---- | ------- | --- |
-| SIM115 | OpenFileWithContextHandler | Use context handler for opening files |  |
 | SIM101 | DuplicateIsinstanceCall | Multiple `isinstance` calls for `...`, merge into a single call | 🛠 |
 | SIM102 | NestedIfStatements | Use a single `if` statement instead of nested `if` statements |  |
 | SIM103 | ReturnBoolConditionDirectly | Return the condition `...` directly | 🛠 |
@@ -990,6 +995,7 @@ For more, see [flake8-simplify](https://pypi.org/project/flake8-simplify/0.19.3/
 | SIM110 | ConvertLoopToAny | Use `return any(x for x in y)` instead of `for` loop | 🛠 |
 | SIM111 | ConvertLoopToAll | Use `return all(x for x in y)` instead of `for` loop | 🛠 |
 | SIM112 | UseCapitalEnvironmentVariables | Use capitalized environment variable `...` instead of `...` | 🛠 |
+| SIM115 | OpenFileWithContextHandler | Use context handler for opening files |  |
 | SIM117 | MultipleWithStatements | Use a single `with` statement with multiple contexts instead of nested `with` statements |  |
 | SIM118 | KeyInDict | Use `key in dict` instead of `key in dict.keys()` | 🛠 |
 | SIM201 | NegateEqualOp | Use `left != right` instead of `not left == right` | 🛠 |
@@ -1084,20 +1090,33 @@ For more, see [pygrep-hooks](https://github.com/pre-commit/pygrep-hooks) on GitH
 
 For more, see [Pylint](https://pypi.org/project/pylint/2.15.7/) on PyPI.
 
+#### Convention (PLC)
 | Code | Name | Message | Fix |
 | ---- | ---- | ------- | --- |
 | PLC0414 | UselessImportAlias | Import alias does not rename original package | 🛠 |
 | PLC2201 | MisplacedComparisonConstant | Comparison should be ... | 🛠 |
 | PLC3002 | UnnecessaryDirectLambdaCall | Lambda expression called directly. Execute the expression inline instead. |  |
+
+#### Error (PLE)
+| Code | Name | Message | Fix |
+| ---- | ---- | ------- | --- |
 | PLE0117 | NonlocalWithoutBinding | Nonlocal name `...` found without binding |  |
 | PLE0118 | UsedPriorGlobalDeclaration | Name `...` is used prior to global declaration on line 1 |  |
 | PLE1142 | AwaitOutsideAsync | `await` should be used within an async function |  |
+
+#### Refactor (PLR)
+| Code | Name | Message | Fix |
+| ---- | ---- | ------- | --- |
+| PLR0133 | ConstantComparison | Two constants compared in a comparison, consider replacing `0 == 0` |  |
 | PLR0206 | PropertyWithParameters | Cannot have defined parameters for properties |  |
 | PLR0402 | ConsiderUsingFromImport | Use `from ... import ...` in lieu of alias |  |
-| PLR0133 | ConstantComparison | Two constants compared in a comparison, consider replacing `0 == 0` |  |
 | PLR1701 | ConsiderMergingIsinstance | Merge these isinstance calls: `isinstance(..., (...))` |  |
 | PLR1722 | UseSysExit | Use `sys.exit()` instead of `exit` | 🛠 |
-| PLR2004 | MagicValueComparison | Magic number used in comparison, consider replacing magic with a constant variable |  |
+| PLR2004 | MagicValueComparison | Magic value used in comparison, consider replacing magic with a constant variable |  |
+
+#### Warning (PLW)
+| Code | Name | Message | Fix |
+| ---- | ---- | ------- | --- |
 | PLW0120 | UselessElseOnLoop | Else clause on loop without a break statement, remove the else and de-indent all the code inside it |  |
 | PLW0602 | GlobalVariableNotAssigned | Using global for `...` but no assignment is done |  |
 
@@ -1111,6 +1130,16 @@ For more, see [flake8-pie](https://pypi.org/project/flake8-pie/0.16.0/) on PyPI.
 | PIE794 | DupeClassFieldDefinitions | Class field `...` is defined multiple times | 🛠 |
 | PIE807 | PreferListBuiltin | Prefer `list()` over useless lambda | 🛠 |
 
+### flake8-commas (COM)
+
+For more, see [flake8-commas](https://pypi.org/project/flake8-commas/2.1.0/) on PyPI.
+
+| Code | Name | Message | Fix |
+| ---- | ---- | ------- | --- |
+| COM812 | TrailingCommaMissing | Trailing comma missing | 🛠 |
+| COM818 | TrailingCommaOnBareTupleProhibited | Trailing comma on bare tuple prohibited |  |
+| COM819 | TrailingCommaProhibited | Trailing comma prohibited | 🛠 |
+
 ### Ruff-specific rules (RUF)
 
 | Code | Name | Message | Fix |
@@ -1395,6 +1424,7 @@ natively, including:
 - [`flake8-boolean-trap`](https://pypi.org/project/flake8-boolean-trap/)
 - [`flake8-bugbear`](https://pypi.org/project/flake8-bugbear/)
 - [`flake8-builtins`](https://pypi.org/project/flake8-builtins/)
+- [`flake8-commas`](https://pypi.org/project/flake8-commas/)
 - [`flake8-comprehensions`](https://pypi.org/project/flake8-comprehensions/)
 - [`flake8-datetimez`](https://pypi.org/project/flake8-datetimez/)
 - [`flake8-debugger`](https://pypi.org/project/flake8-debugger/)
@@ -1460,6 +1490,7 @@ Today, Ruff can be used to replace Flake8 when used with any of the following pl
 - [`flake8-boolean-trap`](https://pypi.org/project/flake8-boolean-trap/)
 - [`flake8-bugbear`](https://pypi.org/project/flake8-bugbear/)
 - [`flake8-builtins`](https://pypi.org/project/flake8-builtins/)
+- [`flake8-commas`](https://pypi.org/project/flake8-commas/)
 - [`flake8-comprehensions`](https://pypi.org/project/flake8-comprehensions/)
 - [`flake8-datetimez`](https://pypi.org/project/flake8-datetimez/)
 - [`flake8-debugger`](https://pypi.org/project/flake8-debugger/)
@@ -2154,6 +2185,25 @@ line-length = 120
 
 ---
 
+#### [`namespace-packages`](#namespace-packages)
+
+Mark the specified directories as namespace packages. For the purpose of
+module resolution, Ruff will treat those directories as if they
+contained an `__init__.py` file.
+
+**Default value**: `[]`
+
+**Type**: `Vec<PathBuf>`
+
+**Example usage**:
+
+```toml
+[tool.ruff]
+namespace-packages = ["airflow/providers"]
+```
+
+---
+
 #### [`per-file-ignores`](#per-file-ignores)
 
 A list of mappings from file pattern to rule codes or prefixes to

flake8_to_ruff/Cargo.lock

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

flake8_to_ruff/Cargo.toml

@@ -1,12 +1,8 @@
 [package]
 name = "flake8-to-ruff"
-version = "0.0.221-dev.0"
+version = "0.0.223"
 edition = "2021"
 
-[lib]
-name = "flake8_to_ruff"
-doctest = false
-
 [dependencies]
 anyhow = { version = "1.0.66" }
 clap = { version = "4.0.1", features = ["derive"] }

flake8_to_ruff/src/lib.rs

@@ -1,18 +0,0 @@
-#![allow(
-    clippy::collapsible_else_if,
-    clippy::collapsible_if,
-    clippy::implicit_hasher,
-    clippy::match_same_arms,
-    clippy::missing_errors_doc,
-    clippy::missing_panics_doc,
-    clippy::module_name_repetitions,
-    clippy::must_use_candidate,
-    clippy::similar_names,
-    clippy::too_many_lines
-)]
-#![forbid(unsafe_code)]
-
-pub mod black;
-pub mod converter;
-mod parser;
-pub mod plugin;

flake8_to_ruff/src/main.rs

@@ -1,4 +1,4 @@
-//! Utility to generate Ruff's pyproject.toml section from a Flake8 INI file.
+//! Utility to generate Ruff's `pyproject.toml` section from a Flake8 INI file.
 #![allow(
     clippy::collapsible_else_if,
     clippy::collapsible_if,
@@ -18,9 +18,7 @@ use std::path::PathBuf;
 use anyhow::Result;
 use clap::Parser;
 use configparser::ini::Ini;
-use flake8_to_ruff::black::parse_black_options;
-use flake8_to_ruff::converter;
-use flake8_to_ruff::plugin::Plugin;
+use ruff::flake8_to_ruff;
 
 #[derive(Parser)]
 #[command(
@@ -38,7 +36,7 @@ struct Cli {
     pyproject: Option<PathBuf>,
     /// List of plugins to enable.
     #[arg(long, value_delimiter = ',')]
-    plugin: Option<Vec<Plugin>>,
+    plugin: Option<Vec<flake8_to_ruff::Plugin>>,
 }
 
 fn main() -> Result<()> {
@@ -52,12 +50,12 @@ fn main() -> Result<()> {
     // Read the pyproject.toml file.
     let black = cli
         .pyproject
-        .map(parse_black_options)
+        .map(flake8_to_ruff::parse_black_options)
         .transpose()?
         .flatten();
 
     // Create Ruff's pyproject.toml section.
-    let pyproject = converter::convert(&config, black.as_ref(), cli.plugin)?;
+    let pyproject = flake8_to_ruff::convert(&config, black.as_ref(), cli.plugin)?;
     println!("{}", toml_edit::easy::to_string_pretty(&pyproject)?);
 
     Ok(())

licenses/LICENSE_PyCQA_flake8-commas

@@ -0,0 +1,45 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 Thomas Grainger.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+
+Portions of this flake8-commas Software may utilize the following
+copyrighted material, the use of which is hereby acknowledged.
+
+Original flake8-commas: https://github.com/trevorcreech/flake8-commas/commit/e8563b71b1d5442e102c8734c11cb5202284293d
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

pyproject.toml

@@ -7,7 +7,7 @@ build-backend = "maturin"
 
 [project]
 name = "ruff"
-version = "0.0.221"
+version = "0.0.223"
 description = "An extremely fast Python linter, written in Rust."
 authors = [
   { name = "Charlie Marsh", email = "charlie.r.marsh@gmail.com" },

resources/test/fixtures/flake8_commas/COM81.py

@@ -0,0 +1,628 @@
+# ==> bad_function_call.py <==
+bad_function_call(
+    param1='test',
+    param2='test'
+)
+# ==> bad_list.py <==
+bad_list = [
+    1,
+    2,
+    3
+]
+
+bad_list_with_comment = [
+    1,
+    2,
+    3
+    # still needs a comma!
+]
+
+bad_list_with_extra_empty = [
+    1,
+    2,
+    3
+
+
+
+]
+
+# ==> bare.py <==
+bar = 1, 2
+
+foo = 1
+
+foo = (1,)
+
+foo = 1,
+
+bar = 1; foo = bar,
+
+foo = (
+3,
+4,
+)
+
+foo = 3, 
+
+class A(object):
+ foo = 3
+ bar = 10,
+ foo_bar = 2
+
+a = ('a',)
+
+from foo import bar, baz
+
+group_by = function_call('arg'),
+
+group_by = ('foobar' * 3),
+
+def foo():
+    return False,
+
+==> callable_before_parenth_form.py <==
+def foo(
+    bar,
+):
+    pass
+
+{'foo': foo}['foo'](
+    bar
+)
+
+{'foo': foo}['foo'](
+    bar,
+)
+
+(foo)(
+    bar
+)
+
+(foo)[0](
+    bar,
+)
+
+[foo][0](
+    bar
+)
+
+[foo][0](
+    bar,
+)
+
+# ==> comment_good_dict.py <==
+multiline_good_dict = {
+    "good": 123,  # this is a good number
+}
+
+# ==> dict_comprehension.py <==
+not_a_dict = {
+    x: y
+    for x, y in ((1, 2), (3, 4))
+}
+
+# ==> good_empty_comma_context.py <==
+def func2(
+):
+    pass
+
+
+func2(
+
+)
+
+func2(
+)
+
+[
+]
+
+[
+
+]
+
+(
+)
+
+(
+
+)
+
+{
+
+}
+
+# ==> good_list.py <==
+stuff = [
+   'a',
+   'b',
+   # more stuff will go here
+]
+
+more_stuff = [
+    'a',
+    'b',
+
+
+
+]
+
+# ==> keyword_before_parenth_form/base_bad.py <==
+from x import (
+    y
+)
+
+assert(
+    SyntaxWarning,
+    ThrownHere,
+    Anyway
+)
+
+# async await is fine outside an async def
+# ruff: RustPython tokenizer treats async/await as keywords, not applicable.
+
+# def await(
+#     foo
+# ):
+#     async(
+#         foo
+#     )
+
+# def async(
+#     foo
+# ):
+#     await(
+#         foo
+#     )
+
+# ==> keyword_before_parenth_form/base.py <==
+from x import (
+    y,
+)
+
+assert(
+    SyntaxWarning,
+    ThrownHere,
+    Anyway,
+)
+
+assert (
+    foo
+)
+
+assert (
+    foo and
+    bar
+)
+
+if(
+    foo and
+    bar
+):
+    pass
+elif(
+    foo and
+    bar
+):
+    pass
+
+for x in(
+    [1,2,3]
+):
+    print(x)
+
+
+(x for x in (
+    [1, 2, 3]
+))
+
+(
+    'foo'
+) is (
+    'foo'
+)
+
+if (
+    foo and
+    bar
+) or not (
+    foo
+) or (
+    spam
+):
+    pass
+
+def xyz():
+    raise(
+        Exception()
+    )
+
+def abc():
+    return(
+        3
+    )
+
+while(
+    False
+):
+    pass
+
+with(
+    loop
+):
+    pass
+
+def foo():
+    yield (
+        "foo"
+    )
+
+# async await is fine outside an async def
+# ruff: RustPython tokenizer treats async/await as keywords, not applicable.
+
+# def await(
+#     foo,
+# ):
+#     async(
+#         foo,
+#     )
+
+# def async(
+#     foo,
+# ):
+#     await(
+#         foo,
+#     )
+
+# ==> keyword_before_parenth_form/py3.py <==
+# Syntax error in Py2
+
+def foo():
+    yield from (
+        foo
+    )
+
+# ==> list_comprehension.py <==
+not_a_list = [
+    s.strip()
+    for s in 'foo, bar, baz'.split(',')
+]
+
+# ==> multiline_bad_dict.py <==
+multiline_bad_dict = {
+    "bad": 123
+}
+# ==> multiline_bad_function_def.py <==
+def func_good(
+        a = 3,
+        b = 2):
+    pass
+
+
+def func_bad(
+        a = 3,
+        b = 2
+    ):
+    pass
+
+# ==> multiline_bad_function_one_param.py <==
+def func(
+        a = 3
+    ):
+    pass
+
+
+func(
+    a = 3
+)
+
+# ==> multiline_bad_or_dict.py <==
+multiline_bad_or_dict = {
+    "good": True or False,
+    "bad": 123
+}
+
+# ==> multiline_good_dict.py <==
+multiline_good_dict = {
+    "good": 123,
+}
+# ==> multiline_good_single_keyed_for_dict.py <==
+good_dict = {
+    "good": x for x in y
+}
+
+# ==> multiline_if.py <==
+if (
+    foo
+    and bar
+):
+    print("Baz")
+
+# ==> multiline_index_access.py <==
+multiline_index_access[
+    "good"
+]
+
+multiline_index_access_after_function()[
+    "good"
+]
+
+multiline_index_access_after_inline_index_access['first'][
+    "good"
+]
+
+multiline_index_access[
+    "probably fine",
+]
+
+[0, 1, 2][
+    "good"
+]
+
+[0, 1, 2][
+    "probably fine",
+]
+
+multiline_index_access[
+    "probably fine",
+    "not good"
+]
+
+multiline_index_access[
+    "fine",
+    "fine",
+    :
+    "not good"
+]
+
+# ==> multiline_string.py <==
+s = (
+    'this' +
+    'is a string'
+)
+
+s2 = (
+    'this'
+    'is a also a string'
+)
+
+t = (
+    'this' +
+    'is a tuple',
+)
+
+t2 = (
+    'this'
+    'is also a tuple',
+)
+
+# ==> multiline_subscript_slice.py <==
+multiline_index_access[
+    "fine",
+    "fine"
+    :
+    "not fine"
+]
+
+multiline_index_access[
+    "fine"
+    "fine"
+    :
+    "fine"
+    :
+    "fine"
+]
+
+multiline_index_access[
+    "fine"
+    "fine",
+    :
+    "fine",
+    :
+    "fine",
+]
+
+multiline_index_access[
+    "fine"
+    "fine",
+    :
+    "fine"
+    :
+    "fine",
+    "not fine"
+]
+
+multiline_index_access[
+    "fine"
+    "fine",
+    :
+    "fine",
+    "fine"
+    :
+    "fine",
+]
+
+multiline_index_access[
+    lambda fine,
+    fine,
+    fine: (0,)
+    :
+    lambda fine,
+    fine,
+    fine: (0,),
+    "fine"
+    :
+    "fine",
+]
+
+# ==> one_line_dict.py <==
+one_line_dict = {"good": 123}
+# ==> parenth_form.py <==
+parenth_form = (
+    a +
+    b +
+    c
+)
+
+parenth_form_with_lambda = (
+    lambda x, y: 0
+)
+
+parenth_form_with_default_lambda = (
+    lambda x=(
+        lambda
+        x,
+        y,
+        :
+        0
+    ),
+    y = {a: b},
+    :
+    0
+)
+
+# ==> prohibited.py <==
+foo = ['a', 'b', 'c',]
+
+bar = { a: b,}
+
+def bah(ham, spam,):
+    pass
+
+(0,)
+
+(0, 1,)
+
+foo = ['a', 'b', 'c', ]
+
+bar = { a: b, }
+
+def bah(ham, spam, ):
+    pass
+
+(0, )
+
+(0, 1, )
+
+image[:, :, 0]
+
+image[:,]
+
+image[:,:,]
+
+lambda x, :
+
+# ==> unpack.py <==
+def function(
+    foo,
+    bar,
+    **kwargs
+):
+    pass
+
+def function(
+    foo,
+    bar,
+    *args
+):
+    pass
+
+def function(
+    foo,
+    bar,
+    *args,
+    extra_kwarg
+    ):
+    pass
+
+result = function(
+    foo,
+    bar,
+    **kwargs
+)
+
+result = function(
+    foo,
+    bar,
+    **not_called_kwargs
+)
+
+def foo(
+    ham,
+    spam,
+    *args,
+    kwarg_only
+    ):
+    pass
+
+# In python 3.5 if it's not a function def, commas are mandatory.
+
+foo(
+    **kwargs
+)
+
+{
+    **kwargs
+}
+
+(
+    *args
+)
+
+{
+    *args
+}
+
+[
+    *args
+]
+
+def foo(
+    ham,
+    spam,
+    *args
+    ):
+    pass
+
+def foo(
+    ham,
+    spam,
+    **kwargs
+    ):
+    pass
+
+def foo(
+    ham,
+    spam,
+    *args,
+    kwarg_only
+    ):
+    pass
+
+# In python 3.5 if it's not a function def, commas are mandatory.
+
+foo(
+    **kwargs,
+)
+
+{
+    **kwargs,
+}
+
+(
+    *args,
+)
+
+{
+    *args,
+}
+
+[
+    *args,
+]
+
+result = function(
+    foo,
+    bar,
+    **{'ham': spam}
+)

resources/test/fixtures/flake8_simplify/SIM117.py

@@ -2,6 +2,11 @@ with A() as a:  # SIM117
     with B() as b:
         print("hello")
 
+with A():  # SIM117
+    with B():
+        with C():
+            print("hello")
+
 with A() as a:
     a()
     with B() as b:
@@ -11,3 +16,15 @@ with A() as a:
     with B() as b:
         print("hello")
     a()
+
+async with A() as a:
+    with B() as b:
+        print("hello")
+
+with A() as a:
+    async with B() as b:
+        print("hello")
+
+async with A() as a:
+    async with B() as b:
+        print("hello")

resources/test/fixtures/pydocstyle/setter.py

@@ -0,0 +1,17 @@
+class PropertyWithSetter:
+    @property
+    def foo(self) -> str:
+        """Docstring for foo."""
+        return "foo"
+
+    @foo.setter
+    def foo(self, value: str) -> None:
+        pass
+
+    @foo.deleter
+    def foo(self):
+        pass
+
+    @foo
+    def foo(self, value: str) -> None:
+        pass

ruff.schema.json

@@ -285,6 +285,16 @@
         }
       ]
     },
+    "namespace-packages": {
+      "description": "Mark the specified directories as namespace packages. For the purpose of module resolution, Ruff will treat those directories as if they contained an `__init__.py` file.",
+      "type": [
+        "array",
+        "null"
+      ],
+      "items": {
+        "type": "string"
+      }
+    },
     "pep8-naming": {
       "description": "Options for the `pep8-naming` plugin.",
       "anyOf": [
@@ -1146,6 +1156,12 @@
         "C9",
         "C90",
         "C901",
+        "COM",
+        "COM8",
+        "COM81",
+        "COM812",
+        "COM818",
+        "COM819",
         "D",
         "D1",
         "D10",

ruff_cli/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ruff_cli"
-version = "0.0.221"
+version = "0.0.223"
 authors = ["Charlie Marsh <charlie.r.marsh@gmail.com>"]
 edition = "2021"
 rust-version = "1.65.0"
@@ -17,6 +17,12 @@ name = "ruff"
 path = "src/main.rs"
 doctest = false
 
+# Since the name of the binary is the same as the name of the `ruff` crate
+# running `cargo doc --no-deps --all` results in an `output filename collision`
+# See also https://github.com/rust-lang/cargo/issues/6313.
+# We therefore disable the documentation generation for the binary.
+doc = false
+
 [dependencies]
 ruff = { path = ".." }
 

ruff_cli/src/cache.rs

@@ -9,7 +9,7 @@ use filetime::FileTime;
 use log::error;
 use path_absolutize::Absolutize;
 use ruff::message::Message;
-use ruff::settings::{flags, Settings};
+use ruff::settings::{flags, AllSettings, Settings};
 use serde::{Deserialize, Serialize};
 
 const CARGO_PKG_VERSION: &str = env!("CARGO_PKG_VERSION");
@@ -80,10 +80,14 @@ fn read_sync(cache_dir: &Path, key: u64) -> Result<Vec<u8>, std::io::Error> {
 pub fn get<P: AsRef<Path>>(
     path: P,
     metadata: &fs::Metadata,
-    settings: &Settings,
+    settings: &AllSettings,
     autofix: flags::Autofix,
 ) -> Option<Vec<Message>> {
-    let encoded = read_sync(&settings.cache_dir, cache_key(path, settings, autofix)).ok()?;
+    let encoded = read_sync(
+        &settings.cli.cache_dir,
+        cache_key(path, &settings.lib, autofix),
+    )
+    .ok()?;
     let (mtime, messages) = match bincode::deserialize::<CheckResult>(&encoded[..]) {
         Ok(CheckResult {
             metadata: CacheMetadata { mtime },
@@ -104,7 +108,7 @@ pub fn get<P: AsRef<Path>>(
 pub fn set<P: AsRef<Path>>(
     path: P,
     metadata: &fs::Metadata,
-    settings: &Settings,
+    settings: &AllSettings,
     autofix: flags::Autofix,
     messages: &[Message],
 ) {
@@ -115,8 +119,8 @@ pub fn set<P: AsRef<Path>>(
         messages,
     };
     if let Err(e) = write_sync(
-        &settings.cache_dir,
-        cache_key(path, settings, autofix),
+        &settings.cli.cache_dir,
+        cache_key(path, &settings.lib, autofix),
         &bincode::serialize(&check_result).unwrap(),
     ) {
         error!("Failed to write to cache: {e:?}");

ruff_cli/src/cli.rs

@@ -2,13 +2,13 @@ use std::path::{Path, PathBuf};
 
 use clap::{command, Parser};
 use regex::Regex;
+use ruff::fs;
 use ruff::logging::LogLevel;
 use ruff::registry::{RuleCode, RuleCodePrefix};
 use ruff::resolver::ConfigProcessor;
 use ruff::settings::types::{
     FilePattern, PatternPrefixPair, PerFileIgnore, PythonVersion, SerializationFormat,
 };
-use ruff::{fs, mccabe};
 use rustc_hash::FxHashMap;
 
 #[derive(Debug, Parser)]
@@ -137,9 +137,6 @@ pub struct Cli {
     /// formatting.
     #[arg(long)]
     pub line_length: Option<usize>,
-    /// Maximum McCabe complexity allowed for a given function.
-    #[arg(long)]
-    pub max_complexity: Option<usize>,
     /// Enable automatic additions of `noqa` directives to failing lines.
     #[arg(
         long,
@@ -266,7 +263,6 @@ impl Cli {
                 fixable: self.fixable,
                 ignore: self.ignore,
                 line_length: self.line_length,
-                max_complexity: self.max_complexity,
                 per_file_ignores: self.per_file_ignores,
                 respect_gitignore: resolve_bool_arg(
                     self.respect_gitignore,
@@ -332,7 +328,6 @@ pub struct Overrides {
     pub fixable: Option<Vec<RuleCodePrefix>>,
     pub ignore: Option<Vec<RuleCodePrefix>>,
     pub line_length: Option<usize>,
-    pub max_complexity: Option<usize>,
     pub per_file_ignores: Option<Vec<PatternPrefixPair>>,
     pub respect_gitignore: Option<bool>,
     pub select: Option<Vec<RuleCodePrefix>>,
@@ -383,11 +378,6 @@ impl ConfigProcessor for &Overrides {
         if let Some(line_length) = &self.line_length {
             config.line_length = Some(*line_length);
         }
-        if let Some(max_complexity) = &self.max_complexity {
-            config.mccabe = Some(mccabe::settings::Options {
-                max_complexity: Some(*max_complexity),
-            });
-        }
         if let Some(per_file_ignores) = &self.per_file_ignores {
             config.per_file_ignores = Some(collect_per_file_ignores(per_file_ignores.clone()));
         }

ruff_cli/src/commands.rs

@@ -19,7 +19,7 @@ use ruff::registry::RuleCode;
 use ruff::resolver::{FileDiscovery, PyprojectDiscovery};
 use ruff::settings::flags;
 use ruff::settings::types::SerializationFormat;
-use ruff::{fix, fs, packaging, resolver, violations, warn_user_once};
+use ruff::{fix, fs, packaging, resolver, warn_user_once, IOError};
 use serde::Serialize;
 use walkdir::WalkDir;
 
@@ -56,19 +56,19 @@ pub fn run(
     if matches!(cache, flags::Cache::Enabled) {
         match &pyproject_strategy {
             PyprojectDiscovery::Fixed(settings) => {
-                if let Err(e) = cache::init(&settings.cache_dir) {
+                if let Err(e) = cache::init(&settings.cli.cache_dir) {
                     error!(
                         "Failed to initialize cache at {}: {e:?}",
-                        settings.cache_dir.to_string_lossy()
+                        settings.cli.cache_dir.to_string_lossy()
                     );
                 }
             }
             PyprojectDiscovery::Hierarchical(default) => {
                 for settings in std::iter::once(default).chain(resolver.iter()) {
-                    if let Err(e) = cache::init(&settings.cache_dir) {
+                    if let Err(e) = cache::init(&settings.cli.cache_dir) {
                         error!(
                             "Failed to initialize cache at {}: {e:?}",
-                            settings.cache_dir.to_string_lossy()
+                            settings.cli.cache_dir.to_string_lossy()
                         );
                     }
                 }
@@ -83,6 +83,8 @@ pub fn run(
             .flatten()
             .map(ignore::DirEntry::path)
             .collect::<Vec<_>>(),
+        &resolver,
+        pyproject_strategy,
     );
 
     let start = Instant::now();
@@ -95,7 +97,7 @@ pub fn run(
                         .parent()
                         .and_then(|parent| package_roots.get(parent))
                         .and_then(|package| *package);
-                    let settings = resolver.resolve(path, pyproject_strategy);
+                    let settings = resolver.resolve_all(path, pyproject_strategy);
                     lint_path(path, package, settings, cache, autofix)
                         .map_err(|e| (Some(path.to_owned()), e.to_string()))
                 }
@@ -114,7 +116,7 @@ pub fn run(
                     let settings = resolver.resolve(path, pyproject_strategy);
                     if settings.enabled.contains(&RuleCode::E902) {
                         Diagnostics::new(vec![Message {
-                            kind: violations::IOError(message).into(),
+                            kind: IOError(message).into(),
                             location: Location::default(),
                             end_location: Location::default(),
                             fix: None,
@@ -169,9 +171,9 @@ pub fn run_stdin(
     };
     let package_root = filename
         .and_then(Path::parent)
-        .and_then(packaging::detect_package_root);
+        .and_then(|path| packaging::detect_package_root(path, &settings.lib.namespace_packages));
     let stdin = read_from_stdin()?;
-    let mut diagnostics = lint_stdin(filename, package_root, &stdin, settings, autofix)?;
+    let mut diagnostics = lint_stdin(filename, package_root, &stdin, &settings.lib, autofix)?;
     diagnostics.messages.sort_unstable();
     Ok(diagnostics)
 }

ruff_cli/src/diagnostics.rs

@@ -9,7 +9,7 @@ use anyhow::Result;
 use log::debug;
 use ruff::linter::{lint_fix, lint_only};
 use ruff::message::Message;
-use ruff::settings::{flags, Settings};
+use ruff::settings::{flags, AllSettings, Settings};
 use ruff::{fix, fs};
 use similar::TextDiff;
 
@@ -38,12 +38,12 @@ impl AddAssign for Diagnostics {
 pub fn lint_path(
     path: &Path,
     package: Option<&Path>,
-    settings: &Settings,
+    settings: &AllSettings,
     cache: flags::Cache,
     autofix: fix::FixMode,
 ) -> Result<Diagnostics> {
     // Validate the `Settings` and return any errors.
-    settings.validate()?;
+    settings.lib.validate()?;
 
     // Check the cache.
     // TODO(charlie): `fixer::Mode::Apply` and `fixer::Mode::Diff` both have
@@ -69,7 +69,7 @@ pub fn lint_path(
 
     // Lint the file.
     let (messages, fixed) = if matches!(autofix, fix::FixMode::Apply | fix::FixMode::Diff) {
-        let (transformed, fixed, messages) = lint_fix(&contents, path, package, settings)?;
+        let (transformed, fixed, messages) = lint_fix(&contents, path, package, &settings.lib)?;
         if fixed > 0 {
             if matches!(autofix, fix::FixMode::Apply) {
                 write(path, transformed)?;
@@ -85,7 +85,7 @@ pub fn lint_path(
         }
         (messages, fixed)
     } else {
-        let messages = lint_only(&contents, path, package, settings, autofix.into())?;
+        let messages = lint_only(&contents, path, package, &settings.lib, autofix.into())?;
         let fixed = 0;
         (messages, fixed)
     };

ruff_cli/src/lib.rs

@@ -1,6 +1,14 @@
+//! This library only exists to enable the Ruff internal tooling (`ruff_dev`)
+//! to automatically update the `ruff --help` output in the `README.md`.
+//!
+//! For the actual Ruff library, see [`ruff`].
 #![allow(clippy::must_use_candidate, dead_code)]
 
 mod cli;
 
-// used by ruff_dev::generate_cli_help
-pub use cli::Cli;
+use clap::CommandFactory;
+
+/// Returns the output of `ruff --help`.
+pub fn help() -> String {
+    cli::Cli::command().render_help().to_string()
+}

ruff_cli/src/main.rs

@@ -16,8 +16,8 @@ use ::ruff::resolver::{
     resolve_settings_with_processor, ConfigProcessor, FileDiscovery, PyprojectDiscovery, Relativity,
 };
 use ::ruff::settings::configuration::Configuration;
+use ::ruff::settings::pyproject;
 use ::ruff::settings::types::SerializationFormat;
-use ::ruff::settings::{pyproject, Settings};
 use ::ruff::{fix, fs, warn_user_once};
 use anyhow::Result;
 use clap::{CommandFactory, Parser};
@@ -26,6 +26,7 @@ use colored::Colorize;
 use notify::{recommended_watcher, RecursiveMode, Watcher};
 use path_absolutize::path_dedot;
 use printer::{Printer, Violations};
+use ruff::settings::{AllSettings, CliSettings};
 
 mod cache;
 mod cli;
@@ -48,7 +49,7 @@ fn resolve(
         // First priority: if we're running in isolated mode, use the default settings.
         let mut config = Configuration::default();
         overrides.process_config(&mut config);
-        let settings = Settings::from_configuration(config, &path_dedot::CWD)?;
+        let settings = AllSettings::from_configuration(config, &path_dedot::CWD)?;
         Ok(PyprojectDiscovery::Fixed(settings))
     } else if let Some(pyproject) = config {
         // Second priority: the user specified a `pyproject.toml` file. Use that
@@ -82,7 +83,7 @@ fn resolve(
         // as the "default" settings.)
         let mut config = Configuration::default();
         overrides.process_config(&mut config);
-        let settings = Settings::from_configuration(config, &path_dedot::CWD)?;
+        let settings = AllSettings::from_configuration(config, &path_dedot::CWD)?;
         Ok(PyprojectDiscovery::Hierarchical(settings))
     }
 }
@@ -113,35 +114,31 @@ pub fn main() -> Result<ExitCode> {
 
     // Validate the `Settings` and return any errors.
     match &pyproject_strategy {
-        PyprojectDiscovery::Fixed(settings) => settings.validate()?,
-        PyprojectDiscovery::Hierarchical(settings) => settings.validate()?,
+        PyprojectDiscovery::Fixed(settings) => settings.lib.validate()?,
+        PyprojectDiscovery::Hierarchical(settings) => settings.lib.validate()?,
     };
 
     // Extract options that are included in `Settings`, but only apply at the top
     // level.
     let file_strategy = FileDiscovery {
         force_exclude: match &pyproject_strategy {
-            PyprojectDiscovery::Fixed(settings) => settings.force_exclude,
-            PyprojectDiscovery::Hierarchical(settings) => settings.force_exclude,
+            PyprojectDiscovery::Fixed(settings) => settings.lib.force_exclude,
+            PyprojectDiscovery::Hierarchical(settings) => settings.lib.force_exclude,
         },
         respect_gitignore: match &pyproject_strategy {
-            PyprojectDiscovery::Fixed(settings) => settings.respect_gitignore,
-            PyprojectDiscovery::Hierarchical(settings) => settings.respect_gitignore,
+            PyprojectDiscovery::Fixed(settings) => settings.lib.respect_gitignore,
+            PyprojectDiscovery::Hierarchical(settings) => settings.lib.respect_gitignore,
         },
     };
-    let (fix, fix_only, format, update_check) = match &pyproject_strategy {
-        PyprojectDiscovery::Fixed(settings) => (
-            settings.fix,
-            settings.fix_only,
-            settings.format,
-            settings.update_check,
-        ),
-        PyprojectDiscovery::Hierarchical(settings) => (
-            settings.fix,
-            settings.fix_only,
-            settings.format,
-            settings.update_check,
-        ),
+    let CliSettings {
+        fix,
+        fix_only,
+        format,
+        update_check,
+        ..
+    } = match &pyproject_strategy {
+        PyprojectDiscovery::Fixed(settings) => settings.cli.clone(),
+        PyprojectDiscovery::Hierarchical(settings) => settings.cli.clone(),
     };
 
     if let Some(code) = cli.explain {
@@ -200,7 +197,7 @@ pub fn main() -> Result<ExitCode> {
         }
 
         // Perform an initial run instantly.
-        printer.clear_screen()?;
+        Printer::clear_screen()?;
         printer.write_to_user("Starting linter in watch mode...\n");
 
         let messages = commands::run(
@@ -211,7 +208,7 @@ pub fn main() -> Result<ExitCode> {
             cache.into(),
             fix::FixMode::None,
         )?;
-        printer.write_continuously(&messages);
+        printer.write_continuously(&messages)?;
 
         // Configure the file watcher.
         let (tx, rx) = channel();
@@ -230,7 +227,7 @@ pub fn main() -> Result<ExitCode> {
                             .unwrap_or_default()
                     });
                     if py_changed {
-                        printer.clear_screen()?;
+                        Printer::clear_screen()?;
                         printer.write_to_user("File change detected...\n");
 
                         let messages = commands::run(
@@ -241,7 +238,7 @@ pub fn main() -> Result<ExitCode> {
                             cache.into(),
                             fix::FixMode::None,
                         )?;
-                        printer.write_continuously(&messages);
+                        printer.write_continuously(&messages)?;
                     }
                 }
                 Err(err) => return Err(err.into()),

ruff_cli/src/printer.rs

@@ -1,4 +1,6 @@
 use std::collections::BTreeMap;
+use std::io;
+use std::io::{BufWriter, Write};
 use std::path::Path;
 
 use annotate_snippets::display_list::{DisplayList, FormatOptions};
@@ -69,7 +71,7 @@ impl<'a> Printer<'a> {
         }
     }
 
-    fn post_text(&self, diagnostics: &Diagnostics) {
+    fn post_text<T: Write>(&self, stdout: &mut T, diagnostics: &Diagnostics) -> Result<()> {
         if self.log_level >= &LogLevel::Default {
             match self.violations {
                 Violations::Show => {
@@ -77,9 +79,12 @@ impl<'a> Printer<'a> {
                     let remaining = diagnostics.messages.len();
                     let total = fixed + remaining;
                     if fixed > 0 {
-                        println!("Found {total} error(s) ({fixed} fixed, {remaining} remaining).");
+                        writeln!(
+                            stdout,
+                            "Found {total} error(s) ({fixed} fixed, {remaining} remaining)."
+                        )?;
                     } else if remaining > 0 {
-                        println!("Found {remaining} error(s).");
+                        writeln!(stdout, "Found {remaining} error(s).")?;
                     }
 
                     if !matches!(self.autofix, fix::FixMode::Apply) {
@@ -89,7 +94,10 @@ impl<'a> Printer<'a> {
                             .filter(|message| message.kind.fixable())
                             .count();
                         if num_fixable > 0 {
-                            println!("{num_fixable} potentially fixable with the --fix option.");
+                            writeln!(
+                                stdout,
+                                "{num_fixable} potentially fixable with the --fix option."
+                            )?;
                         }
                     }
                 }
@@ -97,14 +105,15 @@ impl<'a> Printer<'a> {
                     let fixed = diagnostics.fixed;
                     if fixed > 0 {
                         if matches!(self.autofix, fix::FixMode::Apply) {
-                            println!("Fixed {fixed} error(s).");
+                            writeln!(stdout, "Fixed {fixed} error(s).")?;
                         } else if matches!(self.autofix, fix::FixMode::Diff) {
-                            println!("Would fix {fixed} error(s).");
+                            writeln!(stdout, "Would fix {fixed} error(s).")?;
                         }
                     }
                 }
             }
         }
+        Ok(())
     }
 
     pub fn write_once(&self, diagnostics: &Diagnostics) -> Result<()> {
@@ -113,18 +122,21 @@ impl<'a> Printer<'a> {
         }
 
         if matches!(self.violations, Violations::Hide) {
+            let mut stdout = BufWriter::new(io::stdout().lock());
             if matches!(
                 self.format,
                 SerializationFormat::Text | SerializationFormat::Grouped
             ) {
-                self.post_text(diagnostics);
+                self.post_text(&mut stdout, diagnostics)?;
             }
             return Ok(());
         }
 
+        let mut stdout = BufWriter::new(io::stdout().lock());
         match self.format {
             SerializationFormat::Json => {
-                println!(
+                writeln!(
+                    stdout,
                     "{}",
                     serde_json::to_string_pretty(
                         &diagnostics
@@ -145,7 +157,7 @@ impl<'a> Printer<'a> {
                             })
                             .collect::<Vec<_>>()
                     )?
-                );
+                )?;
             }
             SerializationFormat::Junit => {
                 use quick_junit::{NonSuccessKind, Report, TestCase, TestCaseStatus, TestSuite};
@@ -180,14 +192,14 @@ impl<'a> Printer<'a> {
                     }
                     report.add_test_suite(test_suite);
                 }
-                println!("{}", report.to_string().unwrap());
+                writeln!(stdout, "{}", report.to_string().unwrap())?;
             }
             SerializationFormat::Text => {
                 for message in &diagnostics.messages {
-                    print_message(message);
+                    print_message(&mut stdout, message)?;
                 }
 
-                self.post_text(diagnostics);
+                self.post_text(&mut stdout, diagnostics)?;
             }
             SerializationFormat::Grouped => {
                 for (filename, messages) in group_messages_by_filename(&diagnostics.messages) {
@@ -209,21 +221,25 @@ impl<'a> Printer<'a> {
                     );
 
                     // Print the filename.
-                    println!("{}:", relativize_path(Path::new(&filename)).underline());
+                    writeln!(
+                        stdout,
+                        "{}:",
+                        relativize_path(Path::new(&filename)).underline()
+                    )?;
 
                     // Print each message.
                     for message in messages {
-                        print_grouped_message(message, row_length, column_length);
+                        print_grouped_message(&mut stdout, message, row_length, column_length)?;
                     }
-                    println!();
+                    writeln!(stdout)?;
                 }
 
-                self.post_text(diagnostics);
+                self.post_text(&mut stdout, diagnostics)?;
             }
             SerializationFormat::Github => {
                 // Generate error workflow command in GitHub Actions format.
                 // See: https://docs.github.com/en/actions/reference/workflow-commands-for-github-actions#setting-an-error-message
-                diagnostics.messages.iter().for_each(|message| {
+                for message in &diagnostics.messages {
                     let label = format!(
                         "{}{}{}{}{}{} {} {}",
                         relativize_path(Path::new(&message.filename)),
@@ -235,7 +251,8 @@ impl<'a> Printer<'a> {
                         message.kind.code().as_ref(),
                         message.kind.body(),
                     );
-                    println!(
+                    writeln!(
+                        stdout,
                         "::error title=Ruff \
                          ({}),file={},line={},col={},endLine={},endColumn={}::{}",
                         message.kind.code(),
@@ -245,13 +262,13 @@ impl<'a> Printer<'a> {
                         message.end_location.row(),
                         message.end_location.column(),
                         label,
-                    );
-                });
+                    )?;
+                }
             }
             SerializationFormat::Gitlab => {
                 // Generate JSON with errors in GitLab CI format
                 // https://docs.gitlab.com/ee/ci/testing/code_quality.html#implementing-a-custom-tool
-                println!(
+                writeln!(stdout,
                     "{}",
                     serde_json::to_string_pretty(
                         &diagnostics
@@ -274,16 +291,18 @@ impl<'a> Printer<'a> {
                         )
                         .collect::<Vec<_>>()
                     )?
-                );
+                )?;
             }
         }
 
+        stdout.flush()?;
+
         Ok(())
     }
 
-    pub fn write_continuously(&self, diagnostics: &Diagnostics) {
+    pub fn write_continuously(&self, diagnostics: &Diagnostics) -> Result<()> {
         if matches!(self.log_level, LogLevel::Silent) {
-            return;
+            return Ok(());
         }
 
         if self.log_level >= &LogLevel::Default {
@@ -293,18 +312,21 @@ impl<'a> Printer<'a> {
             );
         }
 
+        let mut stdout = BufWriter::new(io::stdout().lock());
         if !diagnostics.messages.is_empty() {
             if self.log_level >= &LogLevel::Default {
-                println!();
+                writeln!(stdout)?;
             }
             for message in &diagnostics.messages {
-                print_message(message);
+                print_message(&mut stdout, message)?;
             }
         }
+        stdout.flush()?;
+
+        Ok(())
     }
 
-    #[allow(clippy::unused_self)]
-    pub fn clear_screen(&self) -> Result<()> {
+    pub fn clear_screen() -> Result<()> {
         #[cfg(not(target_family = "wasm"))]
         clearscreen::clear()?;
         Ok(())
@@ -330,7 +352,7 @@ fn num_digits(n: usize) -> usize {
 }
 
 /// Print a single `Message` with full details.
-fn print_message(message: &Message) {
+fn print_message<T: Write>(stdout: &mut T, message: &Message) -> Result<()> {
     let label = format!(
         "{}{}{}{}{}{} {} {}",
         relativize_path(Path::new(&message.filename)).bold(),
@@ -342,7 +364,7 @@ fn print_message(message: &Message) {
         message.kind.code().as_ref().red().bold(),
         message.kind.body(),
     );
-    println!("{label}");
+    writeln!(stdout, "{label}")?;
     if let Some(source) = &message.source {
         let commit = message.kind.commit();
         let footer = if commit.is_some() {
@@ -354,7 +376,6 @@ fn print_message(message: &Message) {
         } else {
             vec![]
         };
-
         let snippet = Snippet {
             title: Some(Annotation {
                 label: None,
@@ -384,13 +405,19 @@ fn print_message(message: &Message) {
         // Skip the first line, since we format the `label` ourselves.
         let message = DisplayList::from(snippet).to_string();
         let (_, message) = message.split_once('\n').unwrap();
-        println!("{message}\n");
+        writeln!(stdout, "{message}\n")?;
     }
+    Ok(())
 }
 
 /// Print a grouped `Message`, assumed to be printed in a group with others from
 /// the same file.
-fn print_grouped_message(message: &Message, row_length: usize, column_length: usize) {
+fn print_grouped_message<T: Write>(
+    stdout: &mut T,
+    message: &Message,
+    row_length: usize,
+    column_length: usize,
+) -> Result<()> {
     let label = format!(
         "  {}{}{}{}{}  {}  {}",
         " ".repeat(row_length - num_digits(message.location.row())),
@@ -401,7 +428,7 @@ fn print_grouped_message(message: &Message, row_length: usize, column_length: us
         message.kind.code().as_ref().red().bold(),
         message.kind.body(),
     );
-    println!("{label}");
+    writeln!(stdout, "{label}")?;
     if let Some(source) = &message.source {
         let commit = message.kind.commit();
         let footer = if commit.is_some() {
@@ -413,7 +440,6 @@ fn print_grouped_message(message: &Message, row_length: usize, column_length: us
         } else {
             vec![]
         };
-
         let snippet = Snippet {
             title: Some(Annotation {
                 label: None,
@@ -444,6 +470,7 @@ fn print_grouped_message(message: &Message, row_length: usize, column_length: us
         let message = DisplayList::from(snippet).to_string();
         let (_, message) = message.split_once('\n').unwrap();
         let message = textwrap::indent(message, "  ");
-        println!("{message}");
+        writeln!(stdout, "{message}")?;
     }
+    Ok(())
 }

ruff_cli/tests/black_compatibility_test.rs

@@ -180,7 +180,7 @@ fn test_ruff_black_compatibility() -> Result<()> {
         // problem. Ruff would add a `# noqa: W292`  after the first run, black introduces a
         // newline, and ruff removes the `# noqa: W292` again.
         .filter(|origin| *origin != RuleOrigin::Ruff)
-        .map(|origin| origin.codes().iter().map(AsRef::as_ref).join(","))
+        .map(|origin| origin.prefixes().as_list(","))
         .join(",");
     let ruff_args = [
         "-",

ruff_dev/Cargo.toml

@@ -1,12 +1,8 @@
 [package]
 name = "ruff_dev"
-version = "0.0.221"
+version = "0.0.223"
 edition = "2021"
 
-[lib]
-name = "ruff_dev"
-doctest = false
-
 [dependencies]
 anyhow = { version = "1.0.66" }
 clap = { version = "4.0.1", features = ["derive"] }
@@ -15,9 +11,9 @@ libcst = { git = "https://github.com/charliermarsh/LibCST", rev = "f2f0b7a487a87
 once_cell = { version = "1.16.0" }
 ruff = { path = ".." }
 ruff_cli = { path = "../ruff_cli" }
-rustpython-ast = { features = ["unparse"], git = "https://github.com/RustPython/RustPython.git", rev = "d532160333ffeb6dbeca2c2728c2391cd1e53b7f" }
-rustpython-common = { git = "https://github.com/RustPython/RustPython.git", rev = "d532160333ffeb6dbeca2c2728c2391cd1e53b7f" }
-rustpython-parser = { features = ["lalrpop"], git = "https://github.com/RustPython/RustPython.git", rev = "d532160333ffeb6dbeca2c2728c2391cd1e53b7f" }
+rustpython-ast = { features = ["unparse"], git = "https://github.com/RustPython/RustPython.git", rev = "acbc517b55406c76da83d7b2711941d8d3f65b87" }
+rustpython-common = { git = "https://github.com/RustPython/RustPython.git", rev = "acbc517b55406c76da83d7b2711941d8d3f65b87" }
+rustpython-parser = { features = ["lalrpop"], git = "https://github.com/RustPython/RustPython.git", rev = "acbc517b55406c76da83d7b2711941d8d3f65b87" }
 schemars = { version = "0.8.11" }
 serde_json = {version="1.0.91"}
 strum = { version = "0.24.1", features = ["strum_macros"] }

ruff_dev/src/generate_cli_help.rs

@@ -1,8 +1,7 @@
 //! Generate CLI help.
 
 use anyhow::Result;
-use clap::{Args, CommandFactory};
-use ruff_cli::Cli as MainCli;
+use clap::Args;
 
 use crate::utils::replace_readme_section;
 
@@ -21,8 +20,7 @@ fn trim_lines(s: &str) -> String {
 }
 
 pub fn main(cli: &Cli) -> Result<()> {
-    let mut cmd = MainCli::command();
-    let output = trim_lines(cmd.render_help().to_string().trim());
+    let output = trim_lines(ruff_cli::help().trim());
 
     if cli.dry_run {
         print!("{output}");

ruff_dev/src/generate_rules_table.rs

@@ -2,8 +2,7 @@
 
 use anyhow::Result;
 use clap::Args;
-use itertools::Itertools;
-use ruff::registry::{RuleCode, RuleOrigin};
+use ruff::registry::{Prefixes, RuleCodePrefix, RuleOrigin};
 use strum::IntoEnumIterator;
 
 use crate::utils::replace_readme_section;
@@ -21,12 +20,33 @@ pub struct Cli {
     pub(crate) dry_run: bool,
 }
 
+fn generate_table(table_out: &mut String, prefix: &RuleCodePrefix) {
+    table_out.push_str("| Code | Name | Message | Fix |");
+    table_out.push('\n');
+    table_out.push_str("| ---- | ---- | ------- | --- |");
+    table_out.push('\n');
+    for rule_code in prefix.codes() {
+        let kind = rule_code.kind();
+        let fix_token = if kind.fixable() { "🛠" } else { "" };
+        table_out.push_str(&format!(
+            "| {} | {} | {} | {} |",
+            kind.code().as_ref(),
+            kind.as_ref(),
+            kind.summary().replace('|', r"\|"),
+            fix_token
+        ));
+        table_out.push('\n');
+    }
+    table_out.push('\n');
+}
+
 pub fn main(cli: &Cli) -> Result<()> {
     // Generate the table string.
     let mut table_out = String::new();
     let mut toc_out = String::new();
     for origin in RuleOrigin::iter() {
-        let codes_csv: String = origin.codes().iter().map(AsRef::as_ref).join(", ");
+        let prefixes = origin.prefixes();
+        let codes_csv: String = prefixes.as_list(", ");
         table_out.push_str(&format!("### {} ({codes_csv})", origin.title()));
         table_out.push('\n');
         table_out.push('\n');
@@ -50,26 +70,16 @@ pub fn main(cli: &Cli) -> Result<()> {
             table_out.push('\n');
         }
 
-        table_out.push_str("| Code | Name | Message | Fix |");
-        table_out.push('\n');
-        table_out.push_str("| ---- | ---- | ------- | --- |");
-        table_out.push('\n');
-
-        for rule_code in RuleCode::iter() {
-            if rule_code.origin() == origin {
-                let kind = rule_code.kind();
-                let fix_token = if kind.fixable() { "🛠" } else { "" };
-                table_out.push_str(&format!(
-                    "| {} | {} | {} | {} |",
-                    kind.code().as_ref(),
-                    kind.as_ref(),
-                    kind.summary().replace('|', r"\|"),
-                    fix_token
-                ));
-                table_out.push('\n');
+        match prefixes {
+            Prefixes::Single(prefix) => generate_table(&mut table_out, &prefix),
+            Prefixes::Multiple(entries) => {
+                for (prefix, category) in entries {
+                    table_out.push_str(&format!("#### {category} ({})", prefix.as_ref()));
+                    table_out.push('\n');
+                    generate_table(&mut table_out, &prefix);
+                }
             }
         }
-        table_out.push('\n');
     }
 
     if cli.dry_run {

ruff_dev/src/lib.rs

@@ -1,24 +0,0 @@
-#![allow(
-    clippy::collapsible_else_if,
-    clippy::collapsible_if,
-    clippy::implicit_hasher,
-    clippy::match_same_arms,
-    clippy::missing_errors_doc,
-    clippy::missing_panics_doc,
-    clippy::module_name_repetitions,
-    clippy::must_use_candidate,
-    clippy::similar_names,
-    clippy::too_many_lines
-)]
-#![forbid(unsafe_code)]
-
-pub mod generate_all;
-pub mod generate_cli_help;
-pub mod generate_json_schema;
-pub mod generate_options;
-pub mod generate_rules_table;
-pub mod print_ast;
-pub mod print_cst;
-pub mod print_tokens;
-pub mod round_trip;
-mod utils;

ruff_dev/src/main.rs

@@ -1,3 +1,6 @@
+//! This crate implements an internal CLI for developers of Ruff.
+//!
+//! Within the ruff repository you can run it with `cargo dev`.
 #![allow(
     clippy::collapsible_else_if,
     clippy::collapsible_if,
@@ -12,12 +15,19 @@
 )]
 #![forbid(unsafe_code)]
 
+mod generate_all;
+mod generate_cli_help;
+mod generate_json_schema;
+mod generate_options;
+mod generate_rules_table;
+mod print_ast;
+mod print_cst;
+mod print_tokens;
+mod round_trip;
+mod utils;
+
 use anyhow::Result;
 use clap::{Parser, Subcommand};
-use ruff_dev::{
-    generate_all, generate_cli_help, generate_json_schema, generate_options, generate_rules_table,
-    print_ast, print_cst, print_tokens, round_trip,
-};
 
 #[derive(Parser)]
 #[command(author, version, about, long_about = None)]

ruff_dev/src/round_trip.rs

@@ -5,8 +5,7 @@ use std::path::PathBuf;
 
 use anyhow::Result;
 use clap::Args;
-use ruff::source_code::{Generator, Locator, Stylist};
-use rustpython_parser::parser;
+use ruff::source_code::round_trip;
 
 #[derive(Args)]
 pub struct Cli {
@@ -17,11 +16,6 @@ pub struct Cli {
 
 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 locator = Locator::new(&contents);
-    let stylist = Stylist::from_contents(&contents, &locator);
-    let mut generator: Generator = (&stylist).into();
-    generator.unparse_suite(&python_ast);
-    println!("{}", generator.generate());
+    println!("{}", round_trip(&contents, &cli.file.to_string_lossy())?);
     Ok(())
 }

ruff_macros/Cargo.toml

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

ruff_macros/src/define_rule_mapping.rs

@@ -0,0 +1,133 @@
+use proc_macro2::Span;
+use quote::quote;
+use syn::parse::Parse;
+use syn::{Ident, Path, Token};
+
+pub fn define_rule_mapping(mapping: Mapping) -> proc_macro2::TokenStream {
+    let mut rulecode_variants = quote!();
+    let mut diagkind_variants = quote!();
+    let mut rulecode_kind_match_arms = quote!();
+    let mut rulecode_origin_match_arms = quote!();
+    let mut diagkind_code_match_arms = quote!();
+    let mut diagkind_body_match_arms = quote!();
+    let mut diagkind_fixable_match_arms = quote!();
+    let mut diagkind_commit_match_arms = quote!();
+    let mut from_impls_for_diagkind = quote!();
+
+    for (code, path, name) in mapping.entries {
+        rulecode_variants.extend(quote! {#code,});
+        diagkind_variants.extend(quote! {#name(#path),});
+        rulecode_kind_match_arms.extend(
+            quote! {RuleCode::#code => DiagnosticKind::#name(<#path as Violation>::placeholder()),},
+        );
+        let origin = get_origin(&code);
+        rulecode_origin_match_arms.extend(quote! {RuleCode::#code => RuleOrigin::#origin,});
+        diagkind_code_match_arms.extend(quote! {DiagnosticKind::#name(..) => &RuleCode::#code, });
+        diagkind_body_match_arms
+            .extend(quote! {DiagnosticKind::#name(x) => Violation::message(x), });
+        diagkind_fixable_match_arms
+            .extend(quote! {DiagnosticKind::#name(x) => x.autofix_title_formatter().is_some(),});
+        diagkind_commit_match_arms.extend(
+            quote! {DiagnosticKind::#name(x) => x.autofix_title_formatter().map(|f| f(x)), },
+        );
+        from_impls_for_diagkind.extend(quote! {
+            impl From<#path> for DiagnosticKind {
+                fn from(x: #path) -> Self {
+                    DiagnosticKind::#name(x)
+                }
+            }
+        });
+    }
+
+    quote! {
+        #[derive(
+            AsRefStr,
+            RuleCodePrefix,
+            EnumIter,
+            EnumString,
+            Debug,
+            Display,
+            PartialEq,
+            Eq,
+            Clone,
+            Serialize,
+            Deserialize,
+            Hash,
+            PartialOrd,
+            Ord,
+        )]
+        pub enum RuleCode { #rulecode_variants }
+
+        #[derive(AsRefStr, Debug, PartialEq, Eq, Serialize, Deserialize)]
+        pub enum DiagnosticKind { #diagkind_variants }
+
+
+        impl RuleCode {
+            /// A placeholder representation of the `DiagnosticKind` for the diagnostic.
+            pub fn kind(&self) -> DiagnosticKind {
+                match self { #rulecode_kind_match_arms }
+            }
+
+            pub fn origin(&self) -> RuleOrigin {
+                match self { #rulecode_origin_match_arms }
+            }
+        }
+
+
+        impl DiagnosticKind {
+            /// A four-letter shorthand code for the diagnostic.
+            pub fn code(&self) -> &'static RuleCode {
+                match self { #diagkind_code_match_arms }
+            }
+
+            /// The body text for the diagnostic.
+            pub fn body(&self) -> String {
+                match self { #diagkind_body_match_arms }
+            }
+
+            /// Whether the diagnostic is (potentially) fixable.
+            pub fn fixable(&self) -> bool {
+                match self { #diagkind_fixable_match_arms }
+            }
+
+            /// The message used to describe the fix action for a given `DiagnosticKind`.
+            pub fn commit(&self) -> Option<String> {
+                match self { #diagkind_commit_match_arms }
+            }
+        }
+
+        #from_impls_for_diagkind
+    }
+}
+
+fn get_origin(ident: &Ident) -> Ident {
+    let ident = ident.to_string();
+    let mut iter = crate::prefixes::PREFIX_TO_ORIGIN.iter();
+    let origin = loop {
+        let (prefix, origin) = iter
+            .next()
+            .unwrap_or_else(|| panic!("code doesn't start with any recognized prefix: {ident}"));
+        if ident.starts_with(prefix) {
+            break origin;
+        }
+    };
+    Ident::new(origin, Span::call_site())
+}
+pub struct Mapping {
+    entries: Vec<(Ident, Path, Ident)>,
+}
+
+impl Parse for Mapping {
+    fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
+        let mut entries = Vec::new();
+        while !input.is_empty() {
+            let code: Ident = input.parse()?;
+            let _: Token![=>] = input.parse()?;
+            let path: Path = input.parse()?;
+            let name = path.segments.last().unwrap().ident.clone();
+            let _: Token![,] = input.parse()?;
+            entries.push((code, path, name));
+        }
+        Ok(Mapping { entries })
+    }
+}

ruff_macros/src/lib.rs

@@ -1,3 +1,4 @@
+//! This crate implements internal macros for the `ruff` library.
 #![allow(
     clippy::collapsible_else_if,
     clippy::collapsible_if,
@@ -12,11 +13,10 @@
 )]
 #![forbid(unsafe_code)]
 
-use proc_macro2::Span;
-use quote::quote;
-use syn::{parse_macro_input, DeriveInput, Ident};
+use syn::{parse_macro_input, DeriveInput};
 
 mod config;
+mod define_rule_mapping;
 mod prefixes;
 mod rule_code_prefix;
 
@@ -39,21 +39,7 @@ pub fn derive_rule_code_prefix(input: proc_macro::TokenStream) -> proc_macro::To
 }
 
 #[proc_macro]
-pub fn origin_by_code(item: proc_macro::TokenStream) -> proc_macro::TokenStream {
-    let ident = parse_macro_input!(item as Ident).to_string();
-    let mut iter = prefixes::PREFIX_TO_ORIGIN.iter();
-    let origin = loop {
-        let (prefix, origin) = iter
-            .next()
-            .unwrap_or_else(|| panic!("code doesn't start with any recognized prefix: {ident}"));
-        if ident.starts_with(prefix) {
-            break origin;
-        }
-    };
-    let prefix = Ident::new(origin, Span::call_site());
-
-    quote! {
-        RuleOrigin::#prefix
-    }
-    .into()
+pub fn define_rule_mapping(item: proc_macro::TokenStream) -> proc_macro::TokenStream {
+    let mapping = parse_macro_input!(item as define_rule_mapping::Mapping);
+    define_rule_mapping::define_rule_mapping(mapping).into()
 }

ruff_macros/src/prefixes.rs

@@ -9,6 +9,7 @@ pub const PREFIX_TO_ORIGIN: &[(&str, &str)] = &[
     ("B", "Flake8Bugbear"),
     ("C4", "Flake8Comprehensions"),
     ("C9", "McCabe"),
+    ("COM", "Flake8Commas"),
     ("DTZ", "Flake8Datetimez"),
     ("D", "Pydocstyle"),
     ("ERA", "Eradicate"),

scripts/add_plugin.py

@@ -10,8 +10,9 @@ Example usage:
 
 import argparse
 import os
+from pathlib import Path
 
-ROOT_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+ROOT_DIR = Path(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
 
 
 def dir_name(plugin: str) -> str:
@@ -25,15 +26,16 @@ def pascal_case(plugin: str) -> str:
 def main(*, plugin: str, url: str) -> None:
     # Create the test fixture folder.
     os.makedirs(
-        os.path.join(ROOT_DIR, f"resources/test/fixtures/{dir_name(plugin)}"),
+        ROOT_DIR / "resources/test/fixtures" / dir_name(plugin),
         exist_ok=True,
     )
 
     # Create the Rust module.
-    os.makedirs(os.path.join(ROOT_DIR, f"src/{dir_name(plugin)}"), exist_ok=True)
-    with open(os.path.join(ROOT_DIR, f"src/{dir_name(plugin)}/rules.rs"), "w+") as fp:
+    rust_module = ROOT_DIR / "src/rules" / dir_name(plugin)
+    os.makedirs(rust_module, exist_ok=True)
+    with open(rust_module / "rules.rs", "w+") as fp:
         fp.write("use crate::checkers::ast::Checker;\n")
-    with open(os.path.join(ROOT_DIR, f"src/{dir_name(plugin)}/mod.rs"), "w+") as fp:
+    with open(rust_module / "mod.rs", "w+") as fp:
         fp.write("pub(crate) mod rules;\n")
         fp.write("\n")
         fp.write(
@@ -65,15 +67,14 @@ mod tests {
             % dir_name(plugin)
         )
 
-    # Add the plugin to `lib.rs`.
-    with open(os.path.join(ROOT_DIR, "src/lib.rs"), "a") as fp:
-        fp.write(f"mod {dir_name(plugin)};")
+    # Add the plugin to `rules/mod.rs`.
+    with open(ROOT_DIR / "src/rules/mod.rs", "a") as fp:
+        fp.write(f"pub mod {dir_name(plugin)};")
 
     # Add the relevant sections to `src/registry.rs`.
-    with open(os.path.join(ROOT_DIR, "src/registry.rs")) as fp:
-        content = fp.read()
+    content = (ROOT_DIR / "src/registry.rs").read_text()
 
-    with open(os.path.join(ROOT_DIR, "src/registry.rs"), "w") as fp:
+    with open(ROOT_DIR / "src/registry.rs", "w") as fp:
         for line in content.splitlines():
             if line.strip() == "// Ruff":
                 indent = line.split("// Ruff")[0]
@@ -108,10 +109,9 @@ mod tests {
             fp.write("\n")
 
     # Add the relevant section to `src/violations.rs`.
-    with open(os.path.join(ROOT_DIR, "src/violations.rs")) as fp:
-        content = fp.read()
+    content = (ROOT_DIR / "src/violations.rs").read_text()
 
-    with open(os.path.join(ROOT_DIR, "src/violations.rs"), "w") as fp:
+    with open(ROOT_DIR / "src/violations.rs", "w") as fp:
         for line in content.splitlines():
             if line.strip() == "// Ruff":
                 indent = line.split("// Ruff")[0]

scripts/add_rule.py

@@ -11,8 +11,9 @@ Example usage:
 
 import argparse
 import os
+from pathlib import Path
 
-ROOT_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+ROOT_DIR = Path(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
 
 
 def dir_name(origin: str) -> str:
@@ -32,16 +33,16 @@ def snake_case(name: str) -> str:
 def main(*, name: str, code: str, origin: str) -> None:
     # Create a test fixture.
     with open(
-        os.path.join(ROOT_DIR, f"resources/test/fixtures/{dir_name(origin)}/{code}.py"),
+        ROOT_DIR / "resources/test/fixtures" / dir_name(origin) / f"{code}.py",
         "a",
     ):
         pass
 
     # Add the relevant `#testcase` macro.
-    with open(os.path.join(ROOT_DIR, f"src/{dir_name(origin)}/mod.rs")) as fp:
-        content = fp.read()
+    mod_rs = ROOT_DIR / "src/rules" / dir_name(origin) / "mod.rs"
+    content = mod_rs.read_text()
 
-    with open(os.path.join(ROOT_DIR, f"src/{dir_name(origin)}/mod.rs"), "w") as fp:
+    with open(mod_rs, "w") as fp:
         for line in content.splitlines():
             if line.strip() == "fn rules(rule_code: RuleCode, path: &Path) -> Result<()> {":
                 indent = line.split("fn rules(rule_code: RuleCode, path: &Path) -> Result<()> {")[0]
@@ -52,7 +53,7 @@ def main(*, name: str, code: str, origin: str) -> None:
             fp.write("\n")
 
     # Add the relevant rule function.
-    with open(os.path.join(ROOT_DIR, f"src/{dir_name(origin)}/rules.rs"), "a") as fp:
+    with open(ROOT_DIR / "src/rules" / dir_name(origin) / "rules.rs", "a") as fp:
         fp.write(
             f"""
 /// {code}
@@ -62,10 +63,9 @@ pub fn {snake_case(name)}(checker: &mut Checker) {{}}
         fp.write("\n")
 
     # Add the relevant struct to `src/violations.rs`.
-    with open(os.path.join(ROOT_DIR, "src/violations.rs")) as fp:
-        content = fp.read()
+    content = (ROOT_DIR / "src/violations.rs").read_text()
 
-    with open(os.path.join(ROOT_DIR, "src/violations.rs"), "w") as fp:
+    with open(ROOT_DIR / "src/violations.rs", "w") as fp:
         for line in content.splitlines():
             fp.write(line)
             fp.write("\n")
@@ -90,12 +90,11 @@ impl Violation for %s {
                 fp.write("\n")
 
     # Add the relevant code-to-violation pair to `src/registry.rs`.
-    with open(os.path.join(ROOT_DIR, "src/registry.rs")) as fp:
-        content = fp.read()
+    content = (ROOT_DIR / "src/registry.rs").read_text()
 
     seen_macro = False
     has_written = False
-    with open(os.path.join(ROOT_DIR, "src/registry.rs"), "w") as fp:
+    with open(ROOT_DIR / "src/registry.rs", "w") as fp:
         for line in content.splitlines():
             fp.write(line)
             fp.write("\n")

src/ast/comparable.rs

@@ -1,5 +1,5 @@
-//! An equivalent object hierarchy to the `Expr` hierarchy, but with the ability
-//! to compare expressions for equality (via `Eq` and `Hash`).
+//! An equivalent object hierarchy to the [`Expr`] hierarchy, but with the
+//! ability to compare expressions for equality (via [`Eq`] and [`Hash`]).
 
 use num_bigint::BigInt;
 use rustpython_ast::{

src/ast/helpers.rs

@@ -13,7 +13,7 @@ use rustpython_parser::token::StringKind;
 
 use crate::ast::types::{Binding, BindingKind, Range};
 use crate::checkers::ast::Checker;
-use crate::source_code::{Generator, Locator, Stylist};
+use crate::source_code::{Generator, Indexer, Locator, Stylist};
 
 /// Create an `Expr` with default location from an `ExprKind`.
 pub fn create_expr(node: ExprKind) -> Expr {
@@ -197,7 +197,7 @@ where
 
 static DUNDER_REGEX: Lazy<Regex> = Lazy::new(|| Regex::new(r"__[^\s]+__").unwrap());
 
-/// Return `true` if the `Stmt` is an assignment to a dunder (like `__all__`).
+/// Return `true` if the [`Stmt`] is an assignment to a dunder (like `__all__`).
 pub fn is_assignment_to_a_dunder(stmt: &Stmt) -> bool {
     // Check whether it's an assignment to a dunder, with or without a type
     // annotation. This is what pycodestyle (as of 2.9.1) does.
@@ -219,7 +219,7 @@ pub fn is_assignment_to_a_dunder(stmt: &Stmt) -> bool {
     }
 }
 
-/// Return `true` if the `Expr` is a singleton (`None`, `True`, `False`, or
+/// Return `true` if the [`Expr`] is a singleton (`None`, `True`, `False`, or
 /// `...`).
 pub fn is_singleton(expr: &Expr) -> bool {
     matches!(
@@ -231,7 +231,7 @@ pub fn is_singleton(expr: &Expr) -> bool {
     )
 }
 
-/// Return `true` if the `Expr` is a constant or tuple of constants.
+/// Return `true` if the [`Expr`] is a constant or tuple of constants.
 pub fn is_constant(expr: &Expr) -> bool {
     match &expr.node {
         ExprKind::Constant { .. } => true,
@@ -240,13 +240,13 @@ pub fn is_constant(expr: &Expr) -> bool {
     }
 }
 
-/// Return `true` if the `Expr` is a non-singleton constant.
+/// Return `true` if the [`Expr`] is a non-singleton constant.
 pub fn is_constant_non_singleton(expr: &Expr) -> bool {
     is_constant(expr) && !is_singleton(expr)
 }
 
-/// Return the `Keyword` with the given name, if it's present in the list of
-/// `Keyword` arguments.
+/// Return the [`Keyword`] with the given name, if it's present in the list of
+/// [`Keyword`] arguments.
 pub fn find_keyword<'a>(keywords: &'a [Keyword], keyword_name: &str) -> Option<&'a Keyword> {
     keywords.iter().find(|keyword| {
         let KeywordData { arg, .. } = &keyword.node;
@@ -254,7 +254,7 @@ pub fn find_keyword<'a>(keywords: &'a [Keyword], keyword_name: &str) -> Option<&
     })
 }
 
-/// Return `true` if an `Expr` is `None`.
+/// Return `true` if an [`Expr`] is `None`.
 pub fn is_const_none(expr: &Expr) -> bool {
     matches!(
         &expr.node,
@@ -426,7 +426,7 @@ pub fn match_trailing_content(stmt: &Stmt, locator: &Locator) -> bool {
 /// Return the number of trailing empty lines following a statement.
 pub fn count_trailing_lines(stmt: &Stmt, locator: &Locator) -> usize {
     let suffix =
-        locator.slice_source_code_at(&Location::new(stmt.end_location.unwrap().row() + 1, 0));
+        locator.slice_source_code_at(Location::new(stmt.end_location.unwrap().row() + 1, 0));
     suffix
         .lines()
         .take_while(|line| line.trim().is_empty())
@@ -601,31 +601,62 @@ pub fn else_range(stmt: &Stmt, locator: &Locator) -> Option<Range> {
     }
 }
 
-/// Return `true` if a `Stmt` appears to be part of a multi-statement line, with
-/// other statements preceding it.
-pub fn preceded_by_continuation(stmt: &Stmt, locator: &Locator) -> bool {
-    // Does the previous line end in a continuation? This will have a specific
-    // false-positive, which is that if the previous line ends in a comment, it
-    // will be treated as a continuation. So we should only use this information to
-    // make conservative choices.
-    // TODO(charlie): Come up with a more robust strategy.
-    if stmt.location.row() > 1 {
-        let range = Range::new(
-            Location::new(stmt.location.row() - 1, 0),
-            Location::new(stmt.location.row(), 0),
-        );
-        let line = locator.slice_source_code_range(&range);
-        if line.trim_end().ends_with('\\') {
-            return true;
-        }
-    }
-    false
+/// Return the `Range` of the first `Tok::Colon` token in a `Range`.
+pub fn first_colon_range(range: Range, locator: &Locator) -> Option<Range> {
+    let contents = locator.slice_source_code_range(&range);
+    let range = lexer::make_tokenizer_located(&contents, range.location)
+        .flatten()
+        .find(|(_, kind, _)| matches!(kind, Tok::Colon))
+        .map(|(location, _, end_location)| Range {
+            location,
+            end_location,
+        });
+    range
+}
+
+/// Return the `Range` of the first `Elif` or `Else` token in an `If` statement.
+pub fn elif_else_range(stmt: &Stmt, locator: &Locator) -> Option<Range> {
+    let StmtKind::If { body, orelse, .. } = &stmt.node else {
+        return None;
+    };
+
+    let start = body
+        .last()
+        .expect("Expected body to be non-empty")
+        .end_location
+        .unwrap();
+    let end = match &orelse[..] {
+        [Stmt {
+            node: StmtKind::If { test, .. },
+            ..
+        }] => test.location,
+        [stmt, ..] => stmt.location,
+        _ => return None,
+    };
+    let contents = locator.slice_source_code_range(&Range::new(start, end));
+    let range = lexer::make_tokenizer_located(&contents, start)
+        .flatten()
+        .find(|(_, kind, _)| matches!(kind, Tok::Elif | Tok::Else))
+        .map(|(location, _, end_location)| Range {
+            location,
+            end_location,
+        });
+    range
 }
 
 /// Return `true` if a `Stmt` appears to be part of a multi-statement line, with
 /// other statements preceding it.
-pub fn preceded_by_multi_statement_line(stmt: &Stmt, locator: &Locator) -> bool {
-    match_leading_content(stmt, locator) || preceded_by_continuation(stmt, locator)
+pub fn preceded_by_continuation(stmt: &Stmt, indexer: &Indexer) -> bool {
+    stmt.location.row() > 1
+        && indexer
+            .continuation_lines()
+            .contains(&(stmt.location.row() - 1))
+}
+
+/// Return `true` if a `Stmt` appears to be part of a multi-statement line, with
+/// other statements preceding it.
+pub fn preceded_by_multi_statement_line(stmt: &Stmt, locator: &Locator, indexer: &Indexer) -> bool {
+    match_leading_content(stmt, locator) || preceded_by_continuation(stmt, indexer)
 }
 
 /// Return `true` if a `Stmt` appears to be part of a multi-statement line, with
@@ -696,7 +727,6 @@ impl<'a> SimpleCallArgs<'a> {
     }
 
     /// Get the number of positional and keyword arguments used.
-    #[allow(clippy::len_without_is_empty)]
     pub fn len(&self) -> usize {
         self.args.len() + self.kwargs.len()
     }
@@ -708,7 +738,9 @@ mod tests {
     use rustpython_ast::Location;
     use rustpython_parser::parser;
 
-    use crate::ast::helpers::{else_range, identifier_range, match_trailing_content};
+    use crate::ast::helpers::{
+        elif_else_range, else_range, first_colon_range, identifier_range, match_trailing_content,
+    };
     use crate::ast::types::Range;
     use crate::source_code::Locator;
 
@@ -839,4 +871,54 @@ else:
         assert_eq!(range.end_location.column(), 4);
         Ok(())
     }
+
+    #[test]
+    fn test_first_colon_range() {
+        let contents = "with a: pass";
+        let locator = Locator::new(contents);
+        let range = first_colon_range(
+            Range::new(Location::new(1, 0), Location::new(1, contents.len())),
+            &locator,
+        )
+        .unwrap();
+        assert_eq!(range.location.row(), 1);
+        assert_eq!(range.location.column(), 6);
+        assert_eq!(range.end_location.row(), 1);
+        assert_eq!(range.end_location.column(), 7);
+    }
+
+    #[test]
+    fn test_elif_else_range() -> Result<()> {
+        let contents = "
+if a:
+    ...
+elif b:
+    ...
+"
+        .trim_start();
+        let program = parser::parse_program(contents, "<filename>")?;
+        let stmt = program.first().unwrap();
+        let locator = Locator::new(contents);
+        let range = elif_else_range(stmt, &locator).unwrap();
+        assert_eq!(range.location.row(), 3);
+        assert_eq!(range.location.column(), 0);
+        assert_eq!(range.end_location.row(), 3);
+        assert_eq!(range.end_location.column(), 4);
+        let contents = "
+if a:
+    ...
+else:
+    ...
+"
+        .trim_start();
+        let program = parser::parse_program(contents, "<filename>")?;
+        let stmt = program.first().unwrap();
+        let locator = Locator::new(contents);
+        let range = elif_else_range(stmt, &locator).unwrap();
+        assert_eq!(range.location.row(), 3);
+        assert_eq!(range.location.column(), 0);
+        assert_eq!(range.end_location.row(), 3);
+        assert_eq!(range.end_location.column(), 4);
+        Ok(())
+    }
 }

src/ast/operations.rs

@@ -96,7 +96,7 @@ impl<'a> Visitor<'a> for GlobalVisitor<'a> {
     }
 }
 
-/// Extract a map from global name to its last-defining `Stmt`.
+/// Extract a map from global name to its last-defining [`Stmt`].
 pub fn extract_globals(body: &[Stmt]) -> FxHashMap<&str, &Stmt> {
     let mut visitor = GlobalVisitor::default();
     for stmt in body {
@@ -197,12 +197,12 @@ pub fn is_unpacking_assignment(parent: &Stmt, child: &Expr) -> bool {
 
 pub type LocatedCmpop<U = ()> = Located<Cmpop, U>;
 
-/// Extract all `Cmpop` operators from a source code snippet, with appropriate
+/// Extract all [`Cmpop`] operators from a source code snippet, with appropriate
 /// ranges.
 ///
-/// `RustPython` doesn't include line and column information on `Cmpop` nodes.
+/// `RustPython` doesn't include line and column information on [`Cmpop`] nodes.
 /// `CPython` doesn't either. This method iterates over the token stream and
-/// re-identifies `Cmpop` nodes, annotating them with valid ranges.
+/// re-identifies [`Cmpop`] nodes, annotating them with valid ranges.
 pub fn locate_cmpops(contents: &str) -> Vec<LocatedCmpop> {
     let mut tok_iter = lexer::make_tokenizer(contents).flatten().peekable();
     let mut ops: Vec<LocatedCmpop> = vec![];

src/ast/types.rs

@@ -127,7 +127,7 @@ pub enum BindingKind<'a> {
 pub struct Binding<'a> {
     pub kind: BindingKind<'a>,
     pub range: Range,
-    /// The statement in which the `Binding` was defined.
+    /// The statement in which the [`Binding`] was defined.
     pub source: Option<RefEquality<'a, Stmt>>,
     /// Tuple of (scope index, range) indicating the scope and range at which
     /// the binding was last used.

src/autofix/helpers.rs

@@ -12,7 +12,7 @@ use crate::ast::whitespace::LinesWithTrailingNewline;
 use crate::cst::helpers::compose_module_path;
 use crate::cst::matchers::match_module;
 use crate::fix::Fix;
-use crate::source_code::Locator;
+use crate::source_code::{Indexer, Locator};
 
 /// Determine if a body contains only a single statement, taking into account
 /// deleted.
@@ -79,7 +79,7 @@ fn is_lone_child(child: &Stmt, parent: &Stmt, deleted: &[&Stmt]) -> Result<bool>
 /// Return the location of a trailing semicolon following a `Stmt`, if it's part
 /// of a multi-statement line.
 fn trailing_semicolon(stmt: &Stmt, locator: &Locator) -> Option<Location> {
-    let contents = locator.slice_source_code_at(&stmt.end_location.unwrap());
+    let contents = locator.slice_source_code_at(stmt.end_location.unwrap());
     for (row, line) in LinesWithTrailingNewline::from(&contents).enumerate() {
         let trimmed = line.trim();
         if trimmed.starts_with(';') {
@@ -102,7 +102,7 @@ fn trailing_semicolon(stmt: &Stmt, locator: &Locator) -> Option<Location> {
 /// Find the next valid break for a `Stmt` after a semicolon.
 fn next_stmt_break(semicolon: Location, locator: &Locator) -> Location {
     let start_location = Location::new(semicolon.row(), semicolon.column() + 1);
-    let contents = locator.slice_source_code_at(&start_location);
+    let contents = locator.slice_source_code_at(start_location);
     for (row, line) in LinesWithTrailingNewline::from(&contents).enumerate() {
         let trimmed = line.trim();
         // Skip past any continuations.
@@ -134,7 +134,7 @@ fn next_stmt_break(semicolon: Location, locator: &Locator) -> Location {
 
 /// Return `true` if a `Stmt` occurs at the end of a file.
 fn is_end_of_file(stmt: &Stmt, locator: &Locator) -> bool {
-    let contents = locator.slice_source_code_at(&stmt.end_location.unwrap());
+    let contents = locator.slice_source_code_at(stmt.end_location.unwrap());
     contents.is_empty()
 }
 
@@ -156,6 +156,7 @@ pub fn delete_stmt(
     parent: Option<&Stmt>,
     deleted: &[&Stmt],
     locator: &Locator,
+    indexer: &Indexer,
 ) -> Result<Fix> {
     if parent
         .map(|parent| is_lone_child(stmt, parent, deleted))
@@ -175,7 +176,7 @@ pub fn delete_stmt(
             Fix::deletion(stmt.location, next)
         } else if helpers::match_leading_content(stmt, locator) {
             Fix::deletion(stmt.location, stmt.end_location.unwrap())
-        } else if helpers::preceded_by_continuation(stmt, locator) {
+        } else if helpers::preceded_by_continuation(stmt, indexer) {
             if is_end_of_file(stmt, locator) && stmt.location.column() == 0 {
                 // Special-case: a file can't end in a continuation.
                 Fix::replacement("\n".to_string(), stmt.location, stmt.end_location.unwrap())
@@ -198,6 +199,7 @@ pub fn remove_unused_imports<'a>(
     parent: Option<&Stmt>,
     deleted: &[&Stmt],
     locator: &Locator,
+    indexer: &Indexer,
 ) -> Result<Fix> {
     let module_text = locator.slice_source_code_range(&Range::from_located(stmt));
     let mut tree = match_module(&module_text)?;
@@ -235,7 +237,7 @@ pub fn remove_unused_imports<'a>(
                 if !found_star {
                     bail!("Expected \'*\' for unused import");
                 }
-                return delete_stmt(stmt, parent, deleted, locator);
+                return delete_stmt(stmt, parent, deleted, locator, indexer);
             } else {
                 bail!("Expected: ImportNames::Aliases | ImportNames::Star");
             }
@@ -296,7 +298,7 @@ pub fn remove_unused_imports<'a>(
     }
 
     if aliases.is_empty() {
-        delete_stmt(stmt, parent, deleted, locator)
+        delete_stmt(stmt, parent, deleted, locator, indexer)
     } else {
         let mut state = CodegenState::default();
         tree.codegen(&mut state);

src/autofix/mod.rs

@@ -66,7 +66,7 @@ fn apply_fixes<'a>(
     }
 
     // Add the remaining content.
-    let slice = locator.slice_source_code_at(&last_pos);
+    let slice = locator.slice_source_code_at(last_pos);
     output.append(&slice);
 
     (Cow::from(output.finish()), num_fixed)

src/checkers/ast.rs

@@ -29,20 +29,20 @@ use crate::python::future::ALL_FEATURE_NAMES;
 use crate::python::typing;
 use crate::python::typing::SubscriptKind;
 use crate::registry::{Diagnostic, RuleCode};
+use crate::rules::{
+    flake8_2020, flake8_annotations, flake8_bandit, flake8_blind_except, flake8_boolean_trap,
+    flake8_bugbear, flake8_builtins, flake8_comprehensions, flake8_datetimez, flake8_debugger,
+    flake8_errmsg, flake8_implicit_str_concat, flake8_import_conventions, flake8_pie, flake8_print,
+    flake8_pytest_style, flake8_return, flake8_simplify, flake8_tidy_imports,
+    flake8_unused_arguments, mccabe, pandas_vet, pep8_naming, pycodestyle, pydocstyle, pyflakes,
+    pygrep_hooks, pylint, pyupgrade, ruff,
+};
 use crate::settings::types::PythonVersion;
 use crate::settings::{flags, Settings};
-use crate::source_code::{Locator, Stylist};
+use crate::source_code::{Indexer, Locator, Stylist};
 use crate::violations::DeferralKeyword;
 use crate::visibility::{module_visibility, transition_scope, Modifier, Visibility, VisibleScope};
-use crate::{
-    autofix, docstrings, flake8_2020, flake8_annotations, flake8_bandit, flake8_blind_except,
-    flake8_boolean_trap, flake8_bugbear, flake8_builtins, flake8_comprehensions, flake8_datetimez,
-    flake8_debugger, flake8_errmsg, flake8_implicit_str_concat, flake8_import_conventions,
-    flake8_pie, flake8_print, flake8_pytest_style, flake8_return, flake8_simplify,
-    flake8_tidy_imports, flake8_unused_arguments, mccabe, noqa, pandas_vet, pep8_naming,
-    pycodestyle, pydocstyle, pyflakes, pygrep_hooks, pylint, pyupgrade, ruff, violations,
-    visibility,
-};
+use crate::{autofix, docstrings, noqa, violations, visibility};
 
 const GLOBAL_SCOPE_INDEX: usize = 0;
 
@@ -57,7 +57,8 @@ pub struct Checker<'a> {
     pub(crate) settings: &'a Settings,
     pub(crate) noqa_line_for: &'a IntMap<usize, usize>,
     pub(crate) locator: &'a Locator<'a>,
-    pub(crate) style: &'a Stylist<'a>,
+    pub(crate) stylist: &'a Stylist<'a>,
+    pub(crate) indexer: &'a Indexer,
     // Computed diagnostics.
     pub(crate) diagnostics: Vec<Diagnostic>,
     // Function and class definition tracking (e.g., for docstring enforcement).
@@ -98,6 +99,7 @@ pub struct Checker<'a> {
 }
 
 impl<'a> Checker<'a> {
+    #[allow(clippy::too_many_arguments)]
     pub fn new(
         settings: &'a Settings,
         noqa_line_for: &'a IntMap<usize, usize>,
@@ -106,6 +108,7 @@ impl<'a> Checker<'a> {
         path: &'a Path,
         locator: &'a Locator,
         style: &'a Stylist,
+        indexer: &'a Indexer,
     ) -> Checker<'a> {
         Checker {
             settings,
@@ -114,7 +117,8 @@ impl<'a> Checker<'a> {
             noqa,
             path,
             locator,
-            style,
+            stylist: style,
+            indexer,
             diagnostics: vec![],
             definitions: vec![],
             deletions: FxHashSet::default(),
@@ -1275,7 +1279,7 @@ where
                     }
                 }
             }
-            StmtKind::With { items, body, .. } | StmtKind::AsyncWith { items, body, .. } => {
+            StmtKind::With { items, body, .. } => {
                 if self.settings.enabled.contains(&RuleCode::B017) {
                     flake8_bugbear::rules::assert_raises_exception(self, stmt, items);
                 }
@@ -1283,7 +1287,12 @@ where
                     flake8_pytest_style::rules::complex_raises(self, stmt, items, body);
                 }
                 if self.settings.enabled.contains(&RuleCode::SIM117) {
-                    flake8_simplify::rules::multiple_with_statements(self, stmt);
+                    flake8_simplify::rules::multiple_with_statements(
+                        self,
+                        stmt,
+                        body,
+                        self.current_stmt_parent().map(Into::into),
+                    );
                 }
             }
             StmtKind::While { body, orelse, .. } => {
@@ -3996,6 +4005,7 @@ impl<'a> Checker<'a> {
                             parent,
                             &deleted,
                             self.locator,
+                            self.indexer,
                         ) {
                             Ok(fix) => {
                                 if fix.content.is_empty() || fix.content == "pass" {
@@ -4291,6 +4301,7 @@ pub fn check_ast(
     python_ast: &Suite,
     locator: &Locator,
     stylist: &Stylist,
+    indexer: &Indexer,
     noqa_line_for: &IntMap<usize, usize>,
     settings: &Settings,
     autofix: flags::Autofix,
@@ -4305,6 +4316,7 @@ pub fn check_ast(
         path,
         locator,
         stylist,
+        indexer,
     );
     checker.push_scope(Scope::new(ScopeKind::Module));
     checker.bind_builtins();

src/checkers/imports.rs

@@ -6,16 +6,17 @@ use rustpython_parser::ast::Suite;
 
 use crate::ast::visitor::Visitor;
 use crate::directives::IsortDirectives;
-use crate::isort;
-use crate::isort::track::{Block, ImportTracker};
 use crate::registry::{Diagnostic, RuleCode};
+use crate::rules::isort;
+use crate::rules::isort::track::{Block, ImportTracker};
 use crate::settings::{flags, Settings};
-use crate::source_code::{Locator, Stylist};
+use crate::source_code::{Indexer, Locator, Stylist};
 
 #[allow(clippy::too_many_arguments)]
 pub fn check_imports(
     python_ast: &Suite,
     locator: &Locator,
+    indexer: &Indexer,
     directives: &IsortDirectives,
     settings: &Settings,
     stylist: &Stylist,
@@ -39,7 +40,7 @@ pub fn check_imports(
         for block in &blocks {
             if !block.imports.is_empty() {
                 if let Some(diagnostic) = isort::rules::organize_imports(
-                    block, locator, settings, stylist, autofix, package,
+                    block, locator, indexer, settings, stylist, autofix, package,
                 ) {
                     diagnostics.push(diagnostic);
                 }

src/checkers/lines.rs

@@ -1,9 +1,11 @@
 //! Lint rules based on checking raw physical lines.
 
-use crate::pycodestyle::rules::{doc_line_too_long, line_too_long, no_newline_at_end_of_file};
-use crate::pygrep_hooks::rules::{blanket_noqa, blanket_type_ignore};
-use crate::pyupgrade::rules::unnecessary_coding_comment;
 use crate::registry::{Diagnostic, RuleCode};
+use crate::rules::pycodestyle::rules::{
+    doc_line_too_long, line_too_long, no_newline_at_end_of_file,
+};
+use crate::rules::pygrep_hooks::rules::{blanket_noqa, blanket_type_ignore};
+use crate::rules::pyupgrade::rules::unnecessary_coding_comment;
 use crate::settings::{flags, Settings};
 
 pub fn check_lines(

src/checkers/tokens.rs

@@ -4,10 +4,12 @@ use rustpython_parser::lexer::{LexResult, Tok};
 
 use crate::lex::docstring_detection::StateMachine;
 use crate::registry::{Diagnostic, RuleCode};
-use crate::ruff::rules::Context;
+use crate::rules::ruff::rules::Context;
+use crate::rules::{
+    eradicate, flake8_commas, flake8_implicit_str_concat, flake8_quotes, pycodestyle, ruff,
+};
 use crate::settings::{flags, Settings};
 use crate::source_code::Locator;
-use crate::{eradicate, flake8_implicit_str_concat, flake8_quotes, pycodestyle, ruff};
 
 pub fn check_tokens(
     locator: &Locator,
@@ -28,6 +30,9 @@ pub fn check_tokens(
     let enforce_invalid_escape_sequence = settings.enabled.contains(&RuleCode::W605);
     let enforce_implicit_string_concatenation = settings.enabled.contains(&RuleCode::ISC001)
         || settings.enabled.contains(&RuleCode::ISC002);
+    let enforce_trailing_comma = settings.enabled.contains(&RuleCode::COM812)
+        || settings.enabled.contains(&RuleCode::COM818)
+        || settings.enabled.contains(&RuleCode::COM819);
 
     let mut state_machine = StateMachine::default();
     for &(start, ref tok, end) in tokens.iter().flatten() {
@@ -105,7 +110,16 @@ pub fn check_tokens(
     // ISC001, ISC002
     if enforce_implicit_string_concatenation {
         diagnostics.extend(
-            flake8_implicit_str_concat::rules::implicit(tokens, locator)
+            flake8_implicit_str_concat::rules::implicit(tokens)
+                .into_iter()
+                .filter(|diagnostic| settings.enabled.contains(diagnostic.kind.code())),
+        );
+    }
+
+    // COM812, COM818, COM819
+    if enforce_trailing_comma {
+        diagnostics.extend(
+            flake8_commas::rules::trailing_commas(tokens, locator)
                 .into_iter()
                 .filter(|diagnostic| settings.enabled.contains(diagnostic.kind.code())),
         );

src/directives.rs

@@ -37,14 +37,12 @@ pub struct IsortDirectives {
 }
 
 pub struct Directives {
-    pub commented_lines: Vec<usize>,
     pub noqa_line_for: IntMap<usize, usize>,
     pub isort: IsortDirectives,
 }
 
 pub fn extract_directives(lxr: &[LexResult], flags: Flags) -> Directives {
     Directives {
-        commented_lines: extract_commented_lines(lxr),
         noqa_line_for: if flags.contains(Flags::NOQA) {
             extract_noqa_line_for(lxr)
         } else {
@@ -58,16 +56,6 @@ pub fn extract_directives(lxr: &[LexResult], flags: Flags) -> Directives {
     }
 }
 
-pub fn extract_commented_lines(lxr: &[LexResult]) -> Vec<usize> {
-    let mut commented_lines = Vec::new();
-    for (start, tok, ..) in lxr.iter().flatten() {
-        if matches!(tok, Tok::Comment(_)) {
-            commented_lines.push(start.row());
-        }
-    }
-    commented_lines
-}
-
 /// Extract a mapping from logical line to noqa line.
 pub fn extract_noqa_line_for(lxr: &[LexResult]) -> IntMap<usize, usize> {
     let mut noqa_line_for: IntMap<usize, usize> = IntMap::default();

src/flake8_annotations/snapshots/ruff__flake8_annotations__tests__allow_nested_overload.snap

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

src/flake8_annotations/snapshots/ruff__flake8_annotations__tests__suppress_dummy_args.snap

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

src/flake8_quotes/snapshots/ruff__flake8_quotes__tests__doubles_doubles_noqa.py.snap

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

src/flake8_quotes/snapshots/ruff__flake8_quotes__tests__doubles_doubles_wrapped.py.snap

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

src/flake8_quotes/snapshots/ruff__flake8_quotes__tests__singles_singles_noqa.py.snap

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

src/flake8_quotes/snapshots/ruff__flake8_quotes__tests__singles_singles_wrapped.py.snap

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

src/flake8_simplify/rules/ast_with.rs

@@ -1,22 +0,0 @@
-use rustpython_ast::{Stmt, StmtKind};
-
-use crate::ast::types::Range;
-use crate::checkers::ast::Checker;
-use crate::registry::Diagnostic;
-use crate::violations;
-
-/// SIM117
-pub fn multiple_with_statements(checker: &mut Checker, stmt: &Stmt) {
-    let StmtKind::With { body, .. } = &stmt.node else {
-        return;
-    };
-    if body.len() != 1 {
-        return;
-    }
-    if matches!(body[0].node, StmtKind::With { .. }) {
-        checker.diagnostics.push(Diagnostic::new(
-            violations::MultipleWithStatements,
-            Range::from_located(stmt),
-        ));
-    }
-}

src/flake8_simplify/snapshots/ruff__flake8_simplify__tests__SIM117_SIM117.py.snap

@@ -1,15 +0,0 @@
----
-source: src/flake8_simplify/mod.rs
-expression: checks
----
-- kind:
-    MultipleWithStatements: ~
-  location:
-    row: 1
-    column: 0
-  end_location:
-    row: 3
-    column: 22
-  fix: ~
-  parent: ~
-

src/flake8_to_ruff/black.rs

@@ -3,9 +3,10 @@
 use std::path::Path;
 
 use anyhow::Result;
-use ruff::settings::types::PythonVersion;
 use serde::{Deserialize, Serialize};
 
+use crate::settings::types::PythonVersion;
+
 #[derive(Debug, PartialEq, Eq, Serialize, Deserialize, Default)]
 pub struct Black {
     #[serde(alias = "line-length", alias = "line_length")]

src/flake8_to_ruff/converter.rs

@@ -2,23 +2,24 @@ use std::collections::{BTreeSet, HashMap};
 
 use anyhow::Result;
 use colored::Colorize;
-use ruff::flake8_pytest_style::types::{
+
+use super::black::Black;
+use super::plugin::Plugin;
+use super::{parser, plugin};
+use crate::registry::RuleCodePrefix;
+use crate::rules::flake8_pytest_style::types::{
     ParametrizeNameType, ParametrizeValuesRowType, ParametrizeValuesType,
 };
-use ruff::flake8_quotes::settings::Quote;
-use ruff::flake8_tidy_imports::settings::Strictness;
-use ruff::pydocstyle::settings::Convention;
-use ruff::registry::RuleCodePrefix;
-use ruff::settings::options::Options;
-use ruff::settings::pyproject::Pyproject;
-use ruff::{
+use crate::rules::flake8_quotes::settings::Quote;
+use crate::rules::flake8_tidy_imports::settings::Strictness;
+use crate::rules::pydocstyle::settings::Convention;
+use crate::rules::{
     flake8_annotations, flake8_bugbear, flake8_errmsg, flake8_pytest_style, flake8_quotes,
-    flake8_tidy_imports, mccabe, pep8_naming, pydocstyle, warn_user,
+    flake8_tidy_imports, mccabe, pep8_naming, pydocstyle,
 };
-
-use crate::black::Black;
-use crate::plugin::Plugin;
-use crate::{parser, plugin};
+use crate::settings::options::Options;
+use crate::settings::pyproject::Pyproject;
+use crate::warn_user;
 
 pub fn convert(
     config: &HashMap<String, HashMap<String, Option<String>>>,
@@ -270,7 +271,7 @@ pub fn convert(
                     match value.trim() {
                         "csv" => {
                             flake8_pytest_style.parametrize_names_type =
-                                Some(ParametrizeNameType::CSV);
+                                Some(ParametrizeNameType::Csv);
                         }
                         "tuple" => {
                             flake8_pytest_style.parametrize_names_type =
@@ -388,14 +389,14 @@ mod tests {
     use std::collections::HashMap;
 
     use anyhow::Result;
-    use ruff::pydocstyle::settings::Convention;
-    use ruff::registry::RuleCodePrefix;
-    use ruff::settings::options::Options;
-    use ruff::settings::pyproject::Pyproject;
-    use ruff::{flake8_quotes, pydocstyle};
 
-    use crate::converter::convert;
-    use crate::plugin::Plugin;
+    use super::super::plugin::Plugin;
+    use super::convert;
+    use crate::registry::RuleCodePrefix;
+    use crate::rules::pydocstyle::settings::Convention;
+    use crate::rules::{flake8_quotes, pydocstyle};
+    use crate::settings::options::Options;
+    use crate::settings::pyproject::Pyproject;
 
     #[test]
     fn it_converts_empty() -> Result<()> {
@@ -423,6 +424,7 @@ mod tests {
             ignore: Some(vec![]),
             ignore_init_module_imports: None,
             line_length: None,
+            namespace_packages: None,
             per_file_ignores: None,
             required_version: None,
             respect_gitignore: None,
@@ -488,6 +490,7 @@ mod tests {
             ignore: Some(vec![]),
             ignore_init_module_imports: None,
             line_length: Some(100),
+            namespace_packages: None,
             per_file_ignores: None,
             required_version: None,
             respect_gitignore: None,
@@ -553,6 +556,7 @@ mod tests {
             ignore: Some(vec![]),
             ignore_init_module_imports: None,
             line_length: Some(100),
+            namespace_packages: None,
             per_file_ignores: None,
             required_version: None,
             respect_gitignore: None,
@@ -618,6 +622,7 @@ mod tests {
             ignore: Some(vec![]),
             ignore_init_module_imports: None,
             line_length: None,
+            namespace_packages: None,
             per_file_ignores: None,
             required_version: None,
             respect_gitignore: None,
@@ -683,6 +688,7 @@ mod tests {
             ignore: Some(vec![]),
             ignore_init_module_imports: None,
             line_length: None,
+            namespace_packages: None,
             per_file_ignores: None,
             required_version: None,
             respect_gitignore: None,
@@ -756,6 +762,7 @@ mod tests {
             ignore: Some(vec![]),
             ignore_init_module_imports: None,
             line_length: None,
+            namespace_packages: None,
             per_file_ignores: None,
             required_version: None,
             respect_gitignore: None,
@@ -824,6 +831,7 @@ mod tests {
             ignore: Some(vec![]),
             ignore_init_module_imports: None,
             line_length: None,
+            namespace_packages: None,
             per_file_ignores: None,
             required_version: None,
             respect_gitignore: None,

src/flake8_to_ruff/mod.rs

@@ -0,0 +1,8 @@
+mod black;
+mod converter;
+mod parser;
+mod plugin;
+
+pub use black::parse_black_options;
+pub use converter::convert;
+pub use plugin::Plugin;

src/flake8_to_ruff/parser.rs

@@ -4,11 +4,12 @@ use anyhow::{bail, Result};
 use colored::Colorize;
 use once_cell::sync::Lazy;
 use regex::Regex;
-use ruff::registry::{RuleCodePrefix, PREFIX_REDIRECTS};
-use ruff::settings::types::PatternPrefixPair;
-use ruff::warn_user;
 use rustc_hash::FxHashMap;
 
+use crate::registry::{RuleCodePrefix, PREFIX_REDIRECTS};
+use crate::settings::types::PatternPrefixPair;
+use crate::warn_user;
+
 static COMMA_SEPARATED_LIST_RE: Lazy<Regex> = Lazy::new(|| Regex::new(r"[,\s]").unwrap());
 
 /// Parse a comma-separated list of `RuleCodePrefix` values (e.g.,
@@ -203,10 +204,10 @@ pub fn collect_per_file_ignores(
 #[cfg(test)]
 mod tests {
     use anyhow::Result;
-    use ruff::registry::RuleCodePrefix;
-    use ruff::settings::types::PatternPrefixPair;
 
-    use crate::parser::{parse_files_to_codes_mapping, parse_prefix_codes, parse_strings};
+    use super::{parse_files_to_codes_mapping, parse_prefix_codes, parse_strings};
+    use crate::registry::RuleCodePrefix;
+    use crate::settings::types::PatternPrefixPair;
 
     #[test]
     fn it_parses_prefix_codes() {

src/flake8_to_ruff/plugin.rs

@@ -3,7 +3,8 @@ use std::fmt;
 use std::str::FromStr;
 
 use anyhow::anyhow;
-use ruff::registry::RuleCodePrefix;
+
+use crate::registry::RuleCodePrefix;
 
 #[derive(Clone, Ord, PartialOrd, Eq, PartialEq)]
 pub enum Plugin {
@@ -298,7 +299,7 @@ pub fn resolve_select(plugins: &[Plugin]) -> BTreeSet<RuleCodePrefix> {
 mod tests {
     use std::collections::HashMap;
 
-    use crate::plugin::{infer_plugins_from_options, Plugin};
+    use super::{infer_plugins_from_options, Plugin};
 
     #[test]
     fn it_infers_plugins() {

src/isort/snapshots/ruff__isort__tests__no_reorder_within_section.py.snap

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

src/isort/snapshots/ruff__isort__tests__required_import_empty.py.snap

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

src/isort/snapshots/ruff__isort__tests__required_imports_docstring_only.py.snap

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

src/isort/snapshots/ruff__isort__tests__required_imports_empty.py.snap

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

src/isort/snapshots/ruff__isort__tests__skip_file.py.snap

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

src/isort/snapshots/ruff__isort__tests__split.py.snap

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

src/isort/snapshots/ruff__isort__tests__straight_required_import_docstring_only.py.snap

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

src/isort/snapshots/ruff__isort__tests__straight_required_import_empty.py.snap

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

src/isort/snapshots/ruff__isort__tests__type_comments.py.snap

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

src/lex/docstring_detection.rs

@@ -43,7 +43,10 @@ impl StateMachine {
     }
 
     pub fn consume(&mut self, tok: &Tok) -> bool {
-        if matches!(tok, Tok::Newline | Tok::Indent | Tok::Dedent) {
+        if matches!(
+            tok,
+            Tok::NonLogicalNewline | Tok::Newline | Tok::Indent | Tok::Dedent | Tok::Comment(..)
+        ) {
             return false;
         }
 

src/lib.rs

@@ -1,3 +1,9 @@
+//! This is the library for the [Ruff] Python linter.
+//!
+//! **The API is currently completely unstable**
+//! and subject to change drastically.
+//!
+//! [Ruff]: https://github.com/charliermarsh/ruff
 #![allow(
     clippy::collapsible_else_if,
     clippy::collapsible_if,
@@ -14,66 +20,36 @@
 
 extern crate core;
 
-pub mod ast;
-pub mod autofix;
+mod ast;
+mod autofix;
 pub mod cache;
 mod checkers;
 mod cst;
-pub mod directives;
+mod directives;
 mod doc_lines;
 mod docstrings;
-mod eradicate;
 pub mod fix;
-mod flake8_2020;
-pub mod flake8_annotations;
-pub mod flake8_bandit;
-mod flake8_blind_except;
-pub mod flake8_boolean_trap;
-pub mod flake8_bugbear;
-mod flake8_builtins;
-mod flake8_comprehensions;
-mod flake8_datetimez;
-mod flake8_debugger;
-pub mod flake8_errmsg;
-mod flake8_implicit_str_concat;
-mod flake8_import_conventions;
-pub mod flake8_pie;
-mod flake8_print;
-pub mod flake8_pytest_style;
-pub mod flake8_quotes;
-mod flake8_return;
-mod flake8_simplify;
-pub mod flake8_tidy_imports;
-mod flake8_unused_arguments;
+pub mod flake8_to_ruff;
 pub mod fs;
-mod isort;
 mod lex;
 pub mod linter;
 pub mod logging;
-pub mod mccabe;
 pub mod message;
 mod noqa;
-mod pandas_vet;
-pub mod pep8_naming;
-mod pycodestyle;
-pub mod pydocstyle;
-mod pyflakes;
-mod pygrep_hooks;
-mod pylint;
 mod python;
-mod pyupgrade;
 pub mod registry;
 pub mod resolver;
-mod ruff;
-pub mod rustpython_helpers;
+mod rules;
+mod rustpython_helpers;
 pub mod settings;
 pub mod source_code;
 mod vendor;
 mod violation;
-pub mod violations;
+mod violations;
 mod visibility;
 
 use cfg_if::cfg_if;
+pub use violations::IOError;
 
 cfg_if! {
     if #[cfg(not(target_family = "wasm"))] {

src/lib_native.rs

@@ -10,17 +10,17 @@ use crate::resolver::Relativity;
 use crate::rustpython_helpers::tokenize;
 use crate::settings::configuration::Configuration;
 use crate::settings::{flags, pyproject, Settings};
-use crate::source_code::{Locator, Stylist};
+use crate::source_code::{Indexer, Locator, Stylist};
 use crate::{directives, packaging, resolver};
 
 /// Load the relevant `Settings` for a given `Path`.
 fn resolve(path: &Path) -> Result<Settings> {
     if let Some(pyproject) = pyproject::find_settings_toml(path)? {
         // First priority: `pyproject.toml` in the current `Path`.
-        resolver::resolve_settings(&pyproject, &Relativity::Parent)
+        Ok(resolver::resolve_settings(&pyproject, &Relativity::Parent)?.lib)
     } else if let Some(pyproject) = pyproject::find_user_settings_toml() {
         // Second priority: user-specific `pyproject.toml`.
-        resolver::resolve_settings(&pyproject, &Relativity::Cwd)
+        Ok(resolver::resolve_settings(&pyproject, &Relativity::Cwd)?.lib)
     } else {
         // Fallback: default settings.
         Settings::from_configuration(Configuration::default(), &path_dedot::CWD)
@@ -44,6 +44,9 @@ pub fn check(path: &Path, contents: &str, autofix: bool) -> Result<Vec<Diagnosti
     // Detect the current code style (lazily).
     let stylist = Stylist::from_contents(contents, &locator);
 
+    // Extra indices from the code.
+    let indexer: Indexer = tokens.as_slice().into();
+
     // Extract the `# noqa` and `# isort: skip` directives from the source.
     let directives =
         directives::extract_directives(&tokens, directives::Flags::from_settings(&settings));
@@ -51,11 +54,12 @@ pub fn check(path: &Path, contents: &str, autofix: bool) -> Result<Vec<Diagnosti
     // Generate diagnostics.
     let diagnostics = check_path(
         path,
-        packaging::detect_package_root(path),
+        packaging::detect_package_root(path, &settings.namespace_packages),
         contents,
         tokens,
         &locator,
         &stylist,
+        &indexer,
         &directives,
         &settings,
         autofix.into(),

src/lib_wasm.rs

@@ -5,19 +5,20 @@ use rustpython_parser::lexer::LexResult;
 use serde::Serialize;
 use wasm_bindgen::prelude::*;
 
+use crate::directives;
 use crate::linter::check_path;
 use crate::registry::{RuleCode, RuleCodePrefix};
+use crate::rules::{
+    flake8_annotations, flake8_bandit, flake8_bugbear, flake8_errmsg, flake8_import_conventions,
+    flake8_pytest_style, flake8_quotes, flake8_tidy_imports, flake8_unused_arguments, isort,
+    mccabe, pep8_naming, pycodestyle, pydocstyle, pyupgrade,
+};
 use crate::rustpython_helpers::tokenize;
 use crate::settings::configuration::Configuration;
 use crate::settings::options::Options;
 use crate::settings::types::PythonVersion;
 use crate::settings::{flags, Settings};
-use crate::source_code::{Locator, Stylist};
-use crate::{
-    directives, flake8_annotations, flake8_bandit, flake8_bugbear, flake8_errmsg,
-    flake8_import_conventions, flake8_pytest_style, flake8_quotes, flake8_tidy_imports,
-    flake8_unused_arguments, isort, mccabe, pep8_naming, pycodestyle, pydocstyle, pyupgrade,
-};
+use crate::source_code::{Indexer, Locator, Stylist};
 
 const VERSION: &str = env!("CARGO_PKG_VERSION");
 
@@ -105,14 +106,15 @@ pub fn defaultSettings() -> Result<JsValue, JsValue> {
         force_exclude: None,
         format: None,
         ignore_init_module_imports: None,
+        namespace_packages: None,
         per_file_ignores: None,
         required_version: None,
         respect_gitignore: None,
         show_source: None,
         src: None,
-        unfixable: None,
-        typing_modules: None,
         task_tags: None,
+        typing_modules: None,
+        unfixable: None,
         update_check: None,
         // Use default options for all plugins.
         flake8_annotations: Some(flake8_annotations::settings::Settings::default().into()),
@@ -155,6 +157,9 @@ pub fn check(contents: &str, options: JsValue) -> Result<JsValue, JsValue> {
     // Detect the current code style (lazily).
     let stylist = Stylist::from_contents(contents, &locator);
 
+    // Extra indices from the code.
+    let indexer: Indexer = tokens.as_slice().into();
+
     // Extract the `# noqa` and `# isort: skip` directives from the source.
     let directives = directives::extract_directives(&tokens, directives::Flags::empty());
 
@@ -166,6 +171,7 @@ pub fn check(contents: &str, options: JsValue) -> Result<JsValue, JsValue> {
         tokens,
         &locator,
         &stylist,
+        &indexer,
         &directives,
         &settings,
         flags::Autofix::Enabled,

src/linter.rs

@@ -17,7 +17,7 @@ use crate::message::{Message, Source};
 use crate::noqa::add_noqa;
 use crate::registry::{Diagnostic, LintSource, RuleCode};
 use crate::settings::{flags, Settings};
-use crate::source_code::{Locator, Stylist};
+use crate::source_code::{Indexer, Locator, Stylist};
 use crate::{directives, fs, rustpython_helpers, violations};
 
 const CARGO_PKG_NAME: &str = env!("CARGO_PKG_NAME");
@@ -33,6 +33,7 @@ pub fn check_path(
     tokens: Vec<LexResult>,
     locator: &Locator,
     stylist: &Stylist,
+    indexer: &Indexer,
     directives: &Directives,
     settings: &Settings,
     autofix: flags::Autofix,
@@ -65,7 +66,7 @@ pub fn check_path(
     let use_ast = settings
         .enabled
         .iter()
-        .any(|rule_code| matches!(rule_code.lint_source(), LintSource::AST));
+        .any(|rule_code| matches!(rule_code.lint_source(), LintSource::Ast));
     let use_imports = !directives.isort.skip_file
         && settings
             .enabled
@@ -79,6 +80,7 @@ pub fn check_path(
                         &python_ast,
                         locator,
                         stylist,
+                        indexer,
                         &directives.noqa_line_for,
                         settings,
                         autofix,
@@ -90,6 +92,7 @@ pub fn check_path(
                     diagnostics.extend(check_imports(
                         &python_ast,
                         locator,
+                        indexer,
                         &directives.isort,
                         settings,
                         stylist,
@@ -127,7 +130,7 @@ pub fn check_path(
     {
         diagnostics.extend(check_lines(
             contents,
-            &directives.commented_lines,
+            indexer.commented_lines(),
             &doc_lines,
             settings,
             autofix,
@@ -135,16 +138,16 @@ pub fn check_path(
     }
 
     // Enforce `noqa` directives.
-    if matches!(noqa, flags::Noqa::Enabled)
+    if (matches!(noqa, flags::Noqa::Enabled) && !diagnostics.is_empty())
         || settings
             .enabled
             .iter()
-            .any(|rule_code| matches!(rule_code.lint_source(), LintSource::NoQA))
+            .any(|rule_code| matches!(rule_code.lint_source(), LintSource::NoQa))
     {
         check_noqa(
             &mut diagnostics,
             contents,
-            &directives.commented_lines,
+            indexer.commented_lines(),
             &directives.noqa_line_for,
             settings,
             autofix,
@@ -184,6 +187,9 @@ pub fn add_noqa_to_path(path: &Path, settings: &Settings) -> Result<usize> {
     // Detect the current code style (lazily).
     let stylist = Stylist::from_contents(&contents, &locator);
 
+    // Extra indices from the code.
+    let indexer: Indexer = tokens.as_slice().into();
+
     // Extract the `# noqa` and `# isort: skip` directives from the source.
     let directives =
         directives::extract_directives(&tokens, directives::Flags::from_settings(settings));
@@ -196,6 +202,7 @@ pub fn add_noqa_to_path(path: &Path, settings: &Settings) -> Result<usize> {
         tokens,
         &locator,
         &stylist,
+        &indexer,
         &directives,
         settings,
         flags::Autofix::Disabled,
@@ -230,6 +237,9 @@ pub fn lint_only(
     // Detect the current code style (lazily).
     let stylist = Stylist::from_contents(contents, &locator);
 
+    // Extra indices from the code.
+    let indexer: Indexer = tokens.as_slice().into();
+
     // Extract the `# noqa` and `# isort: skip` directives from the source.
     let directives =
         directives::extract_directives(&tokens, directives::Flags::from_settings(settings));
@@ -242,6 +252,7 @@ pub fn lint_only(
         tokens,
         &locator,
         &stylist,
+        &indexer,
         &directives,
         settings,
         autofix,
@@ -290,6 +301,9 @@ pub fn lint_fix(
         // Detect the current code style (lazily).
         let stylist = Stylist::from_contents(&contents, &locator);
 
+        // Extra indices from the code.
+        let indexer: Indexer = tokens.as_slice().into();
+
         // Extract the `# noqa` and `# isort: skip` directives from the source.
         let directives =
             directives::extract_directives(&tokens, directives::Flags::from_settings(settings));
@@ -302,6 +316,7 @@ pub fn lint_fix(
             tokens,
             &locator,
             &stylist,
+            &indexer,
             &directives,
             settings,
             flags::Autofix::Enabled,
@@ -366,6 +381,7 @@ pub fn test_path(path: &Path, settings: &Settings) -> Result<Vec<Diagnostic>> {
     let tokens: Vec<LexResult> = rustpython_helpers::tokenize(&contents);
     let locator = Locator::new(&contents);
     let stylist = Stylist::from_contents(&contents, &locator);
+    let indexer: Indexer = tokens.as_slice().into();
     let directives =
         directives::extract_directives(&tokens, directives::Flags::from_settings(settings));
     let mut diagnostics = check_path(
@@ -375,6 +391,7 @@ pub fn test_path(path: &Path, settings: &Settings) -> Result<Vec<Diagnostic>> {
         tokens,
         &locator,
         &stylist,
+        &indexer,
         &directives,
         settings,
         flags::Autofix::Enabled,
@@ -395,6 +412,7 @@ pub fn test_path(path: &Path, settings: &Settings) -> Result<Vec<Diagnostic>> {
             let tokens: Vec<LexResult> = rustpython_helpers::tokenize(&contents);
             let locator = Locator::new(&contents);
             let stylist = Stylist::from_contents(&contents, &locator);
+            let indexer: Indexer = tokens.as_slice().into();
             let directives =
                 directives::extract_directives(&tokens, directives::Flags::from_settings(settings));
             let diagnostics = check_path(
@@ -404,6 +422,7 @@ pub fn test_path(path: &Path, settings: &Settings) -> Result<Vec<Diagnostic>> {
                 tokens,
                 &locator,
                 &stylist,
+                &indexer,
                 &directives,
                 settings,
                 flags::Autofix::Enabled,

src/mccabe/snapshots/ruff__mccabe__tests__max_complexity_10.snap

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

src/packaging.rs

@@ -1,9 +1,11 @@
 //! Detect Python package roots and file associations.
 
-use std::path::Path;
+use std::path::{Path, PathBuf};
 
 use rustc_hash::FxHashMap;
 
+use crate::resolver::{PyprojectDiscovery, Resolver};
+
 // If we have a Python package layout like:
 // - root/
 //   - foo/
@@ -27,15 +29,21 @@ use rustc_hash::FxHashMap;
 
 /// Return `true` if the directory at the given `Path` appears to be a Python
 /// package.
-pub fn is_package(path: &Path) -> bool {
+pub fn is_package(path: &Path, namespace_packages: &[PathBuf]) -> bool {
     path.join("__init__.py").is_file()
+        || namespace_packages
+            .iter()
+            .any(|namespace_package| namespace_package == path)
 }
 
 /// Return the package root for the given Python file.
-pub fn detect_package_root(path: &Path) -> Option<&Path> {
+pub fn detect_package_root<'a>(
+    path: &'a Path,
+    namespace_packages: &'a [PathBuf],
+) -> Option<&'a Path> {
     let mut current = None;
     for parent in path.ancestors() {
-        if !is_package(parent) {
+        if !is_package(parent, namespace_packages) {
             return current;
         }
         current = Some(parent);
@@ -46,21 +54,23 @@ pub fn detect_package_root(path: &Path) -> Option<&Path> {
 /// A wrapper around `is_package` to cache filesystem lookups.
 fn is_package_with_cache<'a>(
     path: &'a Path,
+    namespace_packages: &'a [PathBuf],
     package_cache: &mut FxHashMap<&'a Path, bool>,
 ) -> bool {
     *package_cache
         .entry(path)
-        .or_insert_with(|| is_package(path))
+        .or_insert_with(|| is_package(path, namespace_packages))
 }
 
 /// A wrapper around `detect_package_root` to cache filesystem lookups.
 fn detect_package_root_with_cache<'a>(
     path: &'a Path,
+    namespace_packages: &'a [PathBuf],
     package_cache: &mut FxHashMap<&'a Path, bool>,
 ) -> Option<&'a Path> {
     let mut current = None;
     for parent in path.ancestors() {
-        if !is_package_with_cache(parent, package_cache) {
+        if !is_package_with_cache(parent, namespace_packages, package_cache) {
             return current;
         }
         current = Some(parent);
@@ -69,7 +79,11 @@ fn detect_package_root_with_cache<'a>(
 }
 
 /// Return a mapping from Python file to its package root.
-pub fn detect_package_roots<'a>(files: &[&'a Path]) -> FxHashMap<&'a Path, Option<&'a Path>> {
+pub fn detect_package_roots<'a>(
+    files: &[&'a Path],
+    resolver: &'a Resolver,
+    pyproject_strategy: &'a PyprojectDiscovery,
+) -> FxHashMap<&'a Path, Option<&'a Path>> {
     // Pre-populate the module cache, since the list of files could (but isn't
     // required to) contain some `__init__.py` files.
     let mut package_cache: FxHashMap<&Path, bool> = FxHashMap::default();
@@ -84,13 +98,16 @@ pub fn detect_package_roots<'a>(files: &[&'a Path]) -> FxHashMap<&'a Path, Optio
     // Search for the package root for each file.
     let mut package_roots: FxHashMap<&Path, Option<&Path>> = FxHashMap::default();
     for file in files {
+        let namespace_packages = &resolver
+            .resolve(file, pyproject_strategy)
+            .namespace_packages;
         if let Some(package) = file.parent() {
             if package_roots.contains_key(package) {
                 continue;
             }
             package_roots.insert(
                 package,
-                detect_package_root_with_cache(package, &mut package_cache),
+                detect_package_root_with_cache(package, namespace_packages, &mut package_cache),
             );
         }
     }
@@ -111,6 +128,7 @@ mod tests {
                 PathBuf::from(env!("CARGO_MANIFEST_DIR"))
                     .join("resources/test/package/src/package")
                     .as_path(),
+                &[],
             ),
             Some(
                 PathBuf::from(env!("CARGO_MANIFEST_DIR"))
@@ -124,6 +142,7 @@ mod tests {
                 PathBuf::from(env!("CARGO_MANIFEST_DIR"))
                     .join("resources/test/project/python_modules/core/core")
                     .as_path(),
+                &[],
             ),
             Some(
                 PathBuf::from(env!("CARGO_MANIFEST_DIR"))
@@ -137,6 +156,7 @@ mod tests {
                 PathBuf::from(env!("CARGO_MANIFEST_DIR"))
                     .join("resources/test/project/examples/docs/docs/concepts")
                     .as_path(),
+                &[],
             ),
             Some(
                 PathBuf::from(env!("CARGO_MANIFEST_DIR"))
@@ -150,6 +170,7 @@ mod tests {
                 PathBuf::from(env!("CARGO_MANIFEST_DIR"))
                     .join("setup.py")
                     .as_path(),
+                &[],
             ),
             None,
         );

src/pycodestyle/snapshots/ruff__pycodestyle__tests__W292_W292_1.py.snap

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

src/pycodestyle/snapshots/ruff__pycodestyle__tests__W292_W292_2.py.snap

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

src/pycodestyle/snapshots/ruff__pycodestyle__tests__W292_W292_3.py.snap

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

src/pycodestyle/snapshots/ruff__pycodestyle__tests__task_tags_true.snap

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

src/pydocstyle/snapshots/ruff__pydocstyle__tests__D104_D.py.snap

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

src/pydocstyle/snapshots/ruff__pydocstyle__tests__D106_D.py.snap

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

src/pydocstyle/snapshots/ruff__pydocstyle__tests__D206_D.py.snap

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

src/pydocstyle/snapshots/ruff__pydocstyle__tests__D403_D.py.snap

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

src/pydocstyle/snapshots/ruff__pydocstyle__tests__D404_D.py.snap

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

src/pydocstyle/snapshots/ruff__pydocstyle__tests__D413_sections.py.snap

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

src/pydocstyle/snapshots/ruff__pydocstyle__tests__D416_D.py.snap

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

src/pydocstyle/snapshots/ruff__pydocstyle__tests__D417_canonical_google_examples.py.snap

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

src/pydocstyle/snapshots/ruff__pydocstyle__tests__D417_canonical_numpy_examples.py.snap

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

src/pydocstyle/snapshots/ruff__pydocstyle__tests__d417_numpy.snap

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

src/pyflakes/snapshots/ruff__pyflakes__tests__F401_F401_1.py.snap

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

src/pyflakes/snapshots/ruff__pyflakes__tests__F401_F401_2.py.snap

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

src/pyflakes/snapshots/ruff__pyflakes__tests__F401_F401_3.py.snap

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

src/pyflakes/snapshots/ruff__pyflakes__tests__F401_F401_4.py.snap

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

src/pyflakes/snapshots/ruff__pyflakes__tests__F505_F504.py.snap

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

src/pyflakes/snapshots/ruff__pyflakes__tests__F811_F811_10.py.snap

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

src/pyflakes/snapshots/ruff__pyflakes__tests__F811_F811_11.py.snap

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

src/pyflakes/snapshots/ruff__pyflakes__tests__F811_F811_13.py.snap

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

src/pyflakes/snapshots/ruff__pyflakes__tests__F811_F811_14.py.snap

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