Bump version to 0.0.79

Remove leading 'or' from fixable match
Bump version to 0.0.78
2022-10-16 21:39:01 -04:00 · 2022-10-16 21:38:22 -04:00 · 2022-10-16 21:28:25 -04:00 · 2022-10-16 21:27:13 -04:00 · 2022-10-16 21:21:30 -04:00 · 2022-10-16 21:16:57 -04:00
73 changed files with 3091 additions and 969 deletions
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -418,9 +418,9 @@ checksum = "fff857943da45f546682664a79488be82e69e43c1a7a2307679ab9afb3a66d2e"

 [[package]]
 name = "clap"
-version = "4.0.9"
+version = "4.0.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "30607dd93c420c6f1f80b544be522a0238a7db35e6a12968d28910983fee0df0"
+checksum = "6bf8832993da70a4c6d13c581f4463c2bdda27b9bf1c5498dc4365543abe6d6f"
 dependencies = [
 "atty",
 "bitflags",
@@ -433,9 +433,9 @@ dependencies = [

 [[package]]
 name = "clap_derive"
-version = "4.0.9"
+version = "4.0.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a4a307492e1a34939f79d3b6b9650bd2b971513cd775436bf2b78defeb5af00b"
+checksum = "c42f169caba89a7d512b5418b09864543eeb4d497416c917d7137863bd2076ad"
 dependencies = [
 "heck",
 "proc-macro-error",
@@ -466,6 +466,16 @@ dependencies = [
 "winapi 0.3.9",
 ]

+[[package]]
+name = "codespan-reporting"
+version = "0.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3538270d33cc669650c4b093848450d380def10c331d38c768e34cac80576e6e"
+dependencies = [
+ "termcolor",
+ "unicode-width",
+]
+
 [[package]]
 name = "colored"
 version = "2.0.0"
@@ -588,6 +598,50 @@ dependencies = [
 "syn",
 ]

+[[package]]
+name = "cxx"
+version = "1.0.78"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "19f39818dcfc97d45b03953c1292efc4e80954e1583c4aa770bac1383e2310a4"
+dependencies = [
+ "cc",
+ "cxxbridge-flags",
+ "cxxbridge-macro",
+ "link-cplusplus",
+]
+
+[[package]]
+name = "cxx-build"
+version = "1.0.78"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3e580d70777c116df50c390d1211993f62d40302881e54d4b79727acb83d0199"
+dependencies = [
+ "cc",
+ "codespan-reporting",
+ "once_cell",
+ "proc-macro2",
+ "quote",
+ "scratch",
+ "syn",
+]
+
+[[package]]
+name = "cxxbridge-flags"
+version = "1.0.78"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "56a46460b88d1cec95112c8c363f0e2c39afdb237f60583b0b36343bf627ea9c"
+
+[[package]]
+name = "cxxbridge-macro"
+version = "1.0.78"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "747b608fecf06b0d72d440f27acc99288207324b793be2c17991839f3d4995ea"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
 [[package]]
 name = "diff"
 version = "0.1.13"
@@ -954,8 +1008,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4eb1a864a501629691edf6c15a593b7a51eebaa1e8468e9ddc623de7c9b58ec6"
 dependencies = [
 "cfg-if 1.0.0",
+ "js-sys",
 "libc",
 "wasi 0.11.0+wasi-snapshot-preview1",
+ "wasm-bindgen",
 ]

 [[package]]
@@ -981,6 +1037,9 @@ name = "hashbrown"
 version = "0.12.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8a9ee70c43aaf417c914396645a0fa852624801b24ebb7ae78fe8272889ac888"
+dependencies = [
+ "ahash",
+]

 [[package]]
 name = "heck"
@@ -1017,17 +1076,28 @@ checksum = "dfa686283ad6dd069f105e5ab091b04c62850d3e4cf5d67debad1933f55023df"

 [[package]]
 name = "iana-time-zone"
-version = "0.1.50"
+version = "0.1.51"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fd911b35d940d2bd0bea0f9100068e5b97b51a1cbe13d13382f132e0365257a0"
+checksum = "f5a6ef98976b22b3b7f2f3a806f858cb862044cfa66805aa3ad84cb3d3b785ed"
 dependencies = [
 "android_system_properties",
 "core-foundation-sys",
+ "iana-time-zone-haiku",
 "js-sys",
 "wasm-bindgen",
 "winapi 0.3.9",
 ]

+[[package]]
+name = "iana-time-zone-haiku"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fde6edd6cef363e9359ed3c98ba64590ba9eecba2293eb5a723ab32aee8926aa"
+dependencies = [
+ "cxx",
+ "cxx-build",
+]
+
 [[package]]
 name = "idna"
 version = "0.3.0"
@@ -1111,9 +1181,9 @@ dependencies = [

 [[package]]
 name = "itoa"
-version = "1.0.3"
+version = "1.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6c8af84674fe1f223a982c933a0ee1086ac4d4052aa0fb8060c12c6ad838e754"
+checksum = "4217ad341ebadf8d8e724e264f13e593e0648f5b3e94b3896a5df283be015ecc"

 [[package]]
 name = "joinery"
@@ -1225,9 +1295,9 @@ dependencies = [

 [[package]]
 name = "libc"
-version = "0.2.134"
+version = "0.2.135"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "329c933548736bc49fd575ee68c89e8be4d260064184389a5b77517cddd99ffb"
+checksum = "68783febc7782c6c5cb401fbda4de5a9898be1762314da0bb2c10ced61f18b0c"

 [[package]]
 name = "libcst"
@@ -1253,6 +1323,15 @@ dependencies = [
 "syn",
 ]

+[[package]]
+name = "link-cplusplus"
+version = "1.0.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9272ab7b96c9046fbc5bc56c06c117cb639fe2d509df0c421cad82d2915cf369"
+dependencies = [
+ "cc",
+]
+
 [[package]]
 name = "linked-hash-map"
 version = "0.5.6"
@@ -1538,18 +1617,18 @@ checksum = "b1de2e551fb905ac83f73f7aedf2f0cb4a0da7e35efa24a202a936269f1f18e1"

 [[package]]
 name = "path-absolutize"
-version = "3.0.13"
+version = "3.0.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d3de4b40bd9736640f14c438304c09538159802388febb02c8abaae0846c1f13"
+checksum = "0f1d4993b16f7325d90c18c3c6a3327db7808752db8d208cea0acee0abd52c52"
 dependencies = [
 "path-dedot",
 ]

 [[package]]
 name = "path-dedot"
-version = "3.0.17"
+version = "3.0.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d611d5291372b3738a34ebf0d1f849e58b1dcc1101032f76a346eaa1f8ddbb5b"
+checksum = "9a81540d94551664b72b72829b12bd167c73c9d25fbac0e04fafa8023f7e4901"
 dependencies = [
 "once_cell",
 ]
@@ -1966,7 +2045,7 @@ dependencies = [

 [[package]]
 name = "ruff"
-version = "0.0.73"
+version = "0.0.79"
 dependencies = [
 "anyhow",
 "assert_cmd",
@@ -1980,6 +2059,7 @@ dependencies = [
 "dirs 4.0.0",
 "fern",
 "filetime",
+ "getrandom 0.2.7",
 "glob",
 "insta",
 "itertools",
@@ -1999,6 +2079,7 @@ dependencies = [
 "strum",
 "strum_macros",
 "test-case",
+ "textwrap",
 "titlecase",
 "toml",
 "update-informer",
@@ -2020,7 +2101,7 @@ dependencies = [
 [[package]]
 name = "rustpython-ast"
 version = "0.1.0"
-source = "git+https://github.com/charliermarsh/RustPython.git?rev=778ae2aeb521d0438d2a91bd11238bb5c2bf9d4f#778ae2aeb521d0438d2a91bd11238bb5c2bf9d4f"
+source = "git+https://github.com/charliermarsh/RustPython.git?rev=210db77e4274787028dc3ebc0b4841d1334c8c10#210db77e4274787028dc3ebc0b4841d1334c8c10"
 dependencies = [
 "num-bigint",
 "rustpython-common",
@@ -2030,7 +2111,7 @@ dependencies = [
 [[package]]
 name = "rustpython-common"
 version = "0.0.0"
-source = "git+https://github.com/charliermarsh/RustPython.git?rev=778ae2aeb521d0438d2a91bd11238bb5c2bf9d4f#778ae2aeb521d0438d2a91bd11238bb5c2bf9d4f"
+source = "git+https://github.com/charliermarsh/RustPython.git?rev=210db77e4274787028dc3ebc0b4841d1334c8c10#210db77e4274787028dc3ebc0b4841d1334c8c10"
 dependencies = [
 "ascii",
 "cfg-if 1.0.0",
@@ -2053,7 +2134,7 @@ dependencies = [
 [[package]]
 name = "rustpython-compiler-core"
 version = "0.1.2"
-source = "git+https://github.com/charliermarsh/RustPython.git?rev=778ae2aeb521d0438d2a91bd11238bb5c2bf9d4f#778ae2aeb521d0438d2a91bd11238bb5c2bf9d4f"
+source = "git+https://github.com/charliermarsh/RustPython.git?rev=210db77e4274787028dc3ebc0b4841d1334c8c10#210db77e4274787028dc3ebc0b4841d1334c8c10"
 dependencies = [
 "bincode",
 "bitflags",
@@ -2070,7 +2151,7 @@ dependencies = [
 [[package]]
 name = "rustpython-parser"
 version = "0.1.2"
-source = "git+https://github.com/charliermarsh/RustPython.git?rev=778ae2aeb521d0438d2a91bd11238bb5c2bf9d4f#778ae2aeb521d0438d2a91bd11238bb5c2bf9d4f"
+source = "git+https://github.com/charliermarsh/RustPython.git?rev=210db77e4274787028dc3ebc0b4841d1334c8c10#210db77e4274787028dc3ebc0b4841d1334c8c10"
 dependencies = [
 "ahash",
 "anyhow",
@@ -2118,6 +2199,12 @@ version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d29ab0c6d3fc0ee92fe66e2d99f700eab17a8d57d1c1d3b748380fb20baa78cd"

+[[package]]
+name = "scratch"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9c8132065adcfd6e02db789d9285a0deb2f3fcb04002865ab67d5fb103533898"
+
 [[package]]
 name = "sct"
 version = "0.7.0"
@@ -2156,9 +2243,9 @@ dependencies = [

 [[package]]
 name = "serde_json"
-version = "1.0.85"
+version = "1.0.86"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e55a28e3aaef9d5ce0506d0a14dbba8054ddc7e499ef522dd8b26859ec9d4a44"
+checksum = "41feea4228a6f1cd09ec7a3593a682276702cd67b5273544757dae23c096f074"
 dependencies = [
 "itoa",
 "ryu",
@@ -2261,6 +2348,12 @@ version = "1.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a507befe795404456341dfab10cef66ead4c041f62b8b11bbb92bffe5d0953e0"

+[[package]]
+name = "smawk"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f67ad224767faa3c7d8b6d91985b78e70a1324408abcb1cfcc2be4c06bc06043"
+
 [[package]]
 name = "socket2"
 version = "0.4.7"
@@ -2341,9 +2434,9 @@ dependencies = [

 [[package]]
 name = "syn"
-version = "1.0.101"
+version = "1.0.102"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e90cde112c4b9690b8cbe810cba9ddd8bc1d7472e2cae317b69e9438c1cba7d2"
+checksum = "3fcd952facd492f9be3ef0d0b7032a6e442ee9b361d4acc2b1d0c4aaa5f613a1"
 dependencies = [
 "proc-macro2",
 "quote",
@@ -2435,6 +2528,17 @@ dependencies = [
 "syn",
 ]

+[[package]]
+name = "textwrap"
+version = "0.15.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "949517c0cf1bf4ee812e2e07e08ab448e3ae0d23472aee8a06c985f0c8815b16"
+dependencies = [
+ "smawk",
+ "unicode-linebreak",
+ "unicode-width",
+]
+
 [[package]]
 name = "thiserror"
 version = "1.0.37"
@@ -2598,9 +2702,19 @@ checksum = "099b7128301d285f79ddd55b9a83d5e6b9e97c92e0ea0daebee7263e932de992"

 [[package]]
 name = "unicode-ident"
-version = "1.0.4"
+version = "1.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dcc811dc4066ac62f84f11307873c4850cb653bfa9b1719cee2bd2204a4bc5dd"
+checksum = "6ceab39d59e4c9499d4e5a8ee0e2735b891bb7308ac83dfb4e80cad195c9f6f3"
+
+[[package]]
+name = "unicode-linebreak"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c5faade31a542b8b35855fff6e8def199853b2da8da256da52f52f1316ee3137"
+dependencies = [
+ "hashbrown",
+ "regex",
+]

 [[package]]
 name = "unicode-normalization"
@@ -2611,6 +2725,12 @@ dependencies = [
 "tinyvec",
 ]

+[[package]]
+name = "unicode-width"
+version = "0.1.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c0edd1e5b14653f783770bce4a4dabb4a5108a5370a5f5d8cfe8710c361f6c8b"
+
 [[package]]
 name = "unicode-xid"
 version = "0.2.4"
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "ruff"
-version = "0.0.73"
+version = "0.0.79"
 edition = "2021"

 [lib]
@@ -9,10 +9,8 @@ name = "ruff"
 [dependencies]
 anyhow = { version = "1.0.60" }
 bincode = { version = "1.3.3" }
-cacache = { version = "10.0.1" }
 chrono = { version = "0.4.21" }
 clap = { version = "4.0.1", features = ["derive"] }
-clearscreen = { version = "1.0.10" }
 colored = { version = "2.0.0" }
 common-path = { version = "1.0.0" }
 dirs = { version = "4.0.0" }
@@ -25,21 +23,31 @@ log = { version = "0.4.17" }
 notify = { version = "4.0.17" }
 num-bigint = { version = "0.4.3" }
 once_cell = { version = "1.13.1" }
-path-absolutize = { version = "3.0.13", features = ["once_cell_cache"] }
+path-absolutize = { version = "3.0.14", features = ["once_cell_cache", "use_unix_paths_on_wasm"] }
 rayon = { version = "1.5.3" }
 regex = { version = "1.6.0" }
-rustpython-ast = { features = ["unparse"], git = "https://github.com/charliermarsh/RustPython.git", rev = "778ae2aeb521d0438d2a91bd11238bb5c2bf9d4f" }
-rustpython-common = { git = "https://github.com/charliermarsh/RustPython.git", rev = "778ae2aeb521d0438d2a91bd11238bb5c2bf9d4f" }
-rustpython-parser = { features = ["lalrpop"], git = "https://github.com/charliermarsh/RustPython.git", rev = "778ae2aeb521d0438d2a91bd11238bb5c2bf9d4f" }
+rustpython-ast = { features = ["unparse"], git = "https://github.com/charliermarsh/RustPython.git", rev = "210db77e4274787028dc3ebc0b4841d1334c8c10" }
+rustpython-common = { git = "https://github.com/charliermarsh/RustPython.git", rev = "210db77e4274787028dc3ebc0b4841d1334c8c10" }
+rustpython-parser = { features = ["lalrpop"], git = "https://github.com/charliermarsh/RustPython.git", rev = "210db77e4274787028dc3ebc0b4841d1334c8c10" }
 serde = { version = "1.0.143", features = ["derive"] }
 serde_json = { version = "1.0.83" }
 strum = { version = "0.24.1", features = ["strum_macros"] }
 strum_macros = { version = "0.24.3" }
+textwrap = { version = "0.15.1" }
 titlecase = { version = "2.2.1" }
 toml = { version = "0.5.9" }
 update-informer = { version = "0.5.0", default_features = false, features = ["pypi"], optional = true }
 walkdir = { version = "2.3.2" }

+[target.'cfg(not(target_family = "wasm"))'.dependencies]
+cacache = { version = "10.0.1" } # uses async-std
+clearscreen = { version = "1.0.10" } # uses which
+
+# https://docs.rs/getrandom/0.2.7/getrandom/#webassembly-support
+# For (future) wasm-pack support
+[target.'cfg(all(target_family = "wasm", target_os = "unknown"))'.dependencies]
+getrandom = { version = "0.2.7", features = ["js"] }
+
 [dev-dependencies]
 assert_cmd = { version = "2.0.4" }
 insta = { version = "1.19.1", features = ["yaml"] }
--- a/README.md
+++ b/README.md
@@ -1,4 +1,4 @@
-# ruff
+# Ruff

 [![image](https://img.shields.io/pypi/v/ruff.svg)](https://pypi.python.org/pypi/ruff)
 [![image](https://img.shields.io/pypi/l/ruff.svg)](https://pypi.python.org/pypi/ruff)
@@ -20,17 +20,37 @@ An extremely fast Python linter, written in Rust.
 - 🤝 Python 3.10 compatibility
 - 🛠️ `pyproject.toml` support
 - 📦 [ESLint](https://eslint.org/docs/latest/user-guide/command-line-interface#caching)-inspired cache support
- 🔧 [ESLint](https://eslint.org/docs/latest/user-guide/command-line-interface#--fix)-inspired `--fix` support
- 👀 [TypeScript](https://www.typescriptlang.org/docs/handbook/configuring-watch.html)-inspired `--watch` support
- ⚖️ [Near-complete parity](#Parity-with-Flake8) with the built-in Flake8 rule set
+- 🔧 [ESLint](https://eslint.org/docs/latest/user-guide/command-line-interface#--fix)-inspired autofix support (e.g., automatically remove unused imports)
+- 👀 [TypeScript](https://www.typescriptlang.org/docs/handbook/configuring-watch.html)-inspired `--watch` support, for continuous file monitoring
+- ⚖️ [Near-parity](#Parity-with-Flake8) with the built-in Flake8 rule set
+- 🔌 Native re-implementations of popular Flake8 plugins, like [`flake8-docstrings`](https://pypi.org/project/flake8-docstrings/) ([`pydocstyle`](https://pypi.org/project/pydocstyle/))
+
+Ruff aims to be orders of magnitude faster than alternative tools while integrating more
+functionality behind a single, common interface. Ruff can be used to replace Flake8 (plus a variety
+of plugins), [`pydocstyle`](https://pypi.org/project/pydocstyle/), [`yesqa`](https://github.com/asottile/yesqa),
+and even a subset of [`pyupgrade`](https://pypi.org/project/pyupgrade/) and [`autoflake`](https://pypi.org/project/autoflake/)
+all while executing tens or hundreds of times faster than any individual tool.

 Read the [launch blog post](https://notes.crmarsh.com/python-tooling-could-be-much-much-faster).

-## Installation and usage
+## Table of Contents
+
+1. [Installation and Usage](#installation-and-usage)
+2. [Configuration](#configuration)
+3. [Supported Rules](#supported-rules)
+4. [Editor Integrations](#editor-integrations)
+5. [FAQ](#faq)
+6. [Development](#development)
+7. [Releases](#releases)
+8. [Benchmarks](#benchmarks)
+9. [License](#license)
+10. [Contributing](#contributing)
+
+## Installation and Usage

 ### Installation

-Available as [ruff](https://pypi.org/project/ruff/) on PyPI:
+Available as [`ruff`](https://pypi.org/project/ruff/) on PyPI:

 ```shell
 pip install ruff
@@ -38,7 +58,7 @@ pip install ruff

 ### Usage

-To run ruff, try any of the following:
+To run Ruff, try any of the following:

 ```shell
 ruff path/to/code/to/check.py
@@ -46,27 +66,27 @@ ruff path/to/code/
 ruff path/to/code/*.py
 ```

-You can run ruff in `--watch` mode to automatically re-run on-change:
+You can run Ruff in `--watch` mode to automatically re-run on-change:

 ```shell
 ruff path/to/code/ --watch
 ```

-ruff also works with [pre-commit](https://pre-commit.com):
+Ruff also works with [pre-commit](https://pre-commit.com):

 ```yaml
 repos:
  - repo: https://github.com/charliermarsh/ruff-pre-commit
-    rev: v0.0.73
+    rev: v0.0.79
    hooks:
      - id: lint
 ```

 ## Configuration

-ruff is configurable both via `pyproject.toml` and the command line.
+Ruff is configurable both via `pyproject.toml` and the command line.

-For example, you could configure ruff to only enforce a subset of rules with:
+For example, you could configure Ruff to only enforce a subset of rules with:

 ```toml
 [tool.ruff]
@@ -158,7 +178,7 @@ Exclusions are based on globs, and can be either:
 To omit a lint check entirely, add it to the "ignore" list via `--ignore` or `--extend-ignore`,
 either  on the command-line or in your `project.toml` file.

-To ignore an error in-line, ruff uses a `noqa` system similar to [Flake8](https://flake8.pycqa.org/en/3.1.1/user/ignoring-errors.html).
+To ignore an error in-line, Ruff uses a `noqa` system similar to [Flake8](https://flake8.pycqa.org/en/3.1.1/user/ignoring-errors.html).
 To ignore an individual error, add `# noqa: {code}` to the end of the line, like so:

 ```python
@@ -182,195 +202,220 @@ Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor i
 """  # noqa: E501
 ```

-ruff supports several (experimental) workflows to aid in `noqa` management.
+Ruff supports several workflows to aid in `noqa` management.

-First, ruff provides a special error code, `M001`, to enforce that your `noqa` directives are
+First, Ruff provides a special error code, `M001`, to enforce that your `noqa` directives are
 "valid", in that the errors they _say_ they ignore are actually being triggered on that line (and
 thus suppressed). **You can run `ruff /path/to/file.py --extend-select M001` to flag unused `noqa`
 directives.**

-Second, ruff can _automatically remove_ unused `noqa` directives via its autofix functionality.
+Second, Ruff can _automatically remove_ unused `noqa` directives via its autofix functionality.
 **You can run `ruff /path/to/file.py --extend-select M001 --fix` to automatically remove unused
 `noqa` directives.**

-Third, ruff can _automatically add_ `noqa` directives to all failing lines. This is useful when
-migrating a new codebase to ruff. **You can run `ruff /path/to/file.py --add-noqa` to automatically
+Third, Ruff can _automatically add_ `noqa` directives to all failing lines. This is useful when
+migrating a new codebase to Ruff. **You can run `ruff /path/to/file.py --add-noqa` to automatically
 add `noqa` directives to all failing lines, with the appropriate error codes.**

-### Compatibility with Black
+## Supported Rules

-ruff is compatible with [Black](https://github.com/psf/black) out-of-the-box, as long as
-the `line-length` setting is consistent between the two.
-
-As a project, ruff is designed to be used alongside Black and, as such, will defer implementing
-stylistic lint rules that are obviated by autoformatting.
-
-### Parity with Flake8
-
-ruff's goal is to achieve feature parity with Flake8 when used (1) without plugins, (2) alongside
-Black, and (3) on Python 3 code.
-
-**Under those conditions, ruff implements 44 out of 60 rules.** (ruff is missing: 14 rules related
-to string `.format` calls, 1 rule related to docstring parsing, and 1 rule related to redefined
-variables.)
-
-ruff also implements some of the most popular Flake8 plugins natively, including:
-
- [`flake8-builtins`](https://pypi.org/project/flake8-builtins/)
- [`flake8-super`](https://pypi.org/project/flake8-super/)
- [`flake8-print`](https://pypi.org/project/flake8-print/)
- [`flake8-comprehensions`](https://pypi.org/project/flake8-comprehensions/) (15/16)
- [`flake8-bugbear`](https://pypi.org/project/flake8-bugbear/) (3/32)
- [`flake8-docstrings`](https://pypi.org/project/flake8-docstrings/) (37/48)
- [`pyupgrade`](https://pypi.org/project/pyupgrade/) (8/34)
-
-Beyond rule-set parity, ruff suffers from the following limitations vis-à-vis Flake8:
-
-1. ruff does not yet support a few Python 3.9 and 3.10 language features, including structural
-   pattern matching and parenthesized context managers.
-2. Flake8 has a plugin architecture and supports writing custom lint rules.
-
-## Rules
-
-The ✅ emoji indicates a rule is enabled by default.
+By default, Ruff enables all `E`, `W`, and `F` error codes, which correspond to those built-in to
+Flake8.

 The 🛠 emoji indicates that a rule is automatically fixable by the `--fix` command-line option.

-| Code | Name | Message |     |     |
-| ---- | ---- | ------- | --- | --- |
-| E402 | ModuleImportNotAtTopOfFile | Module level import not at top of file | ✅ |  |
-| E501 | LineTooLong | Line too long (89 > 88 characters) | ✅ |  |
-| E711 | NoneComparison | Comparison to `None` should be `cond is None` | ✅ |  |
-| E712 | TrueFalseComparison | Comparison to `True` should be `cond is True` | ✅ |  |
-| E713 | NotInTest | Test for membership should be `not in` | ✅ |  |
-| E714 | NotIsTest | Test for object identity should be `is not` | ✅ |  |
-| E721 | TypeComparison | Do not compare types, use `isinstance()` | ✅ |  |
-| E722 | DoNotUseBareExcept | Do not use bare `except` | ✅ |  |
-| E731 | DoNotAssignLambda | Do not assign a lambda expression, use a def | ✅ |  |
-| E741 | AmbiguousVariableName | Ambiguous variable name: `...` | ✅ |  |
-| E742 | AmbiguousClassName | Ambiguous class name: `...` | ✅ |  |
-| E743 | AmbiguousFunctionName | Ambiguous function name: `...` | ✅ |  |
-| E902 | IOError | IOError: `...` | ✅ |  |
-| E999 | SyntaxError | SyntaxError: `...` | ✅ |  |
-| W292 | NoNewLineAtEndOfFile | No newline at end of file | ✅ |  |
-| F401 | UnusedImport | `...` imported but unused | ✅ | 🛠 |
-| F402 | ImportShadowedByLoopVar | Import `...` from line 1 shadowed by loop variable | ✅ |  |
-| F403 | ImportStarUsed | `from ... import *` used; unable to detect undefined names | ✅ |  |
-| F404 | LateFutureImport | `from __future__` imports must occur at the beginning of the file | ✅ |  |
-| F405 | ImportStarUsage | `...` may be undefined, or defined from star imports: `...` | ✅ |  |
-| F406 | ImportStarNotPermitted | `from ... import *` only allowed at module level | ✅ |  |
-| F407 | FutureFeatureNotDefined | Future feature `...` is not defined | ✅ |  |
-| F541 | FStringMissingPlaceholders | f-string without any placeholders | ✅ |  |
-| F601 | MultiValueRepeatedKeyLiteral | Dictionary key literal repeated | ✅ |  |
-| F602 | MultiValueRepeatedKeyVariable | Dictionary key `...` repeated | ✅ |  |
-| F621 | ExpressionsInStarAssignment | Too many expressions in star-unpacking assignment | ✅ |  |
-| F622 | TwoStarredExpressions | Two starred expressions in assignment | ✅ |  |
-| F631 | AssertTuple | Assert test is a non-empty tuple, which is always `True` | ✅ |  |
-| F632 | IsLiteral | Use `==` and `!=` to compare constant literals | ✅ |  |
-| F633 | InvalidPrintSyntax | Use of `>>` is invalid with `print` function | ✅ |  |
-| F634 | IfTuple | If test is a tuple, which is always `True` | ✅ |  |
-| F701 | BreakOutsideLoop | `break` outside loop | ✅ |  |
-| F702 | ContinueOutsideLoop | `continue` not properly in loop | ✅ |  |
-| F704 | YieldOutsideFunction | `yield` or `yield from` statement outside of a function/method | ✅ |  |
-| F706 | ReturnOutsideFunction | `return` statement outside of a function/method | ✅ |  |
-| F707 | DefaultExceptNotLast | An `except:` block as not the last exception handler | ✅ |  |
-| F722 | ForwardAnnotationSyntaxError | Syntax error in forward annotation: `...` | ✅ |  |
-| F821 | UndefinedName | Undefined name `...` | ✅ |  |
-| F822 | UndefinedExport | Undefined name `...` in `__all__` | ✅ |  |
-| F823 | UndefinedLocal | Local variable `...` referenced before assignment | ✅ |  |
-| F831 | DuplicateArgumentName | Duplicate argument name in function definition | ✅ |  |
-| F841 | UnusedVariable | Local variable `...` is assigned to but never used | ✅ |  |
-| F901 | RaiseNotImplemented | `raise NotImplemented` should be `raise NotImplementedError` | ✅ |  |
-| A001 | BuiltinVariableShadowing | Variable `...` is shadowing a python builtin |  |  |
-| A002 | BuiltinArgumentShadowing | Argument `...` is shadowing a python builtin |  |  |
-| A003 | BuiltinAttributeShadowing | Class attribute `...` is shadowing a python builtin |  |  |
-| B011 | DoNotAssertFalse | Do not `assert False` (`python -O` removes these calls), raise `AssertionError()` |  | 🛠 |
-| B014 | DuplicateHandlerException | Exception handler with duplicate exception: `ValueError` |  | 🛠 |
-| B025 | DuplicateTryBlockException | try-except block with duplicate exception `Exception` |  |  |
-| C400 | UnnecessaryGeneratorList | Unnecessary generator - rewrite as a list comprehension |  |  |
-| C401 | UnnecessaryGeneratorSet | Unnecessary generator - rewrite as a set comprehension |  |  |
-| C402 | UnnecessaryGeneratorDict | Unnecessary generator - rewrite as a dict comprehension |  |  |
-| C403 | UnnecessaryListComprehensionSet | Unnecessary list comprehension - rewrite as a set comprehension |  |  |
-| C404 | UnnecessaryListComprehensionDict | Unnecessary list comprehension - rewrite as a dict comprehension |  |  |
-| C405 | UnnecessaryLiteralSet | Unnecessary <list/tuple> literal - rewrite as a set literal |  |  |
-| C406 | UnnecessaryLiteralDict | Unnecessary <list/tuple> literal - rewrite as a dict literal |  |  |
-| C408 | UnnecessaryCollectionCall | Unnecessary <dict/list/tuple> call - rewrite as a literal |  |  |
-| C409 | UnnecessaryLiteralWithinTupleCall | Unnecessary <list/tuple> literal passed to tuple() - remove the outer call to tuple() |  |  |
-| C410 | UnnecessaryLiteralWithinListCall | Unnecessary <list/tuple> literal passed to list() - rewrite as a list literal |  |  |
-| C411 | UnnecessaryListCall | Unnecessary list call - remove the outer call to list() |  |  |
-| C413 | UnnecessaryCallAroundSorted | Unnecessary <list/reversed> call around sorted() |  |  |
-| C414 | UnnecessaryDoubleCastOrProcess | Unnecessary <list/reversed/set/sorted/tuple> call within <list/set/sorted/tuple>(). |  |  |
-| C415 | UnnecessarySubscriptReversal | Unnecessary subscript reversal of iterable within <reversed/set/sorted>() |  |  |
-| C416 | UnnecessaryComprehension |  Unnecessary <list/set> comprehension - rewrite using <list/set>() |  |  |
-| T201 | PrintFound | `print` found |  | 🛠 |
-| T203 | PPrintFound | `pprint` found |  | 🛠 |
-| U001 | UselessMetaclassType | `__metaclass__ = type` is implied |  | 🛠 |
-| U002 | UnnecessaryAbspath | `abspath(__file__)` is unnecessary in Python 3.9 and later |  | 🛠 |
-| U003 | TypeOfPrimitive | Use `str` instead of `type(...)` |  | 🛠 |
-| U004 | UselessObjectInheritance | Class `...` inherits from object |  | 🛠 |
-| U005 | DeprecatedUnittestAlias | `assertEquals` is deprecated, use `assertEqual` instead |  | 🛠 |
-| U006 | UsePEP585Annotation | Use `list` instead of `List` for type annotations |  | 🛠 |
-| U007 | UsePEP604Annotation | Use `X \| Y` for type annotations |  | 🛠 |
-| U008 | SuperCallWithParameters | Use `super()` instead of `super(__class__, self)` |  | 🛠 |
-| D100 | PublicModule | Missing docstring in public module |  |  |
-| D101 | PublicClass | Missing docstring in public class |  |  |
-| D102 | PublicMethod | Missing docstring in public method |  |  |
-| D103 | PublicFunction | Missing docstring in public function |  |  |
-| D104 | PublicPackage | Missing docstring in public package |  |  |
-| D105 | MagicMethod | Missing docstring in magic method |  |  |
-| D106 | PublicNestedClass | Missing docstring in public nested class |  |  |
-| D107 | PublicInit | Missing docstring in __init__ |  |  |
-| D200 | FitsOnOneLine | One-line docstring should fit on one line |  |  |
-| D201 | NoBlankLineBeforeFunction | No blank lines allowed before function docstring (found 1) |  |  |
-| D202 | NoBlankLineAfterFunction | No blank lines allowed after function docstring (found 1) |  |  |
-| D203 | OneBlankLineBeforeClass | 1 blank line required before class docstring |  |  |
-| D204 | OneBlankLineAfterClass | 1 blank line required after class docstring |  |  |
-| D205 | NoBlankLineAfterSummary | 1 blank line required between summary line and description |  |  |
-| D209 | NewLineAfterLastParagraph | Multi-line docstring closing quotes should be on a separate line |  |  |
-| D210 | NoSurroundingWhitespace | No whitespaces allowed surrounding docstring text |  |  |
-| D211 | NoBlankLineBeforeClass | No blank lines allowed before class docstring |  |  |
-| D212 | MultiLineSummaryFirstLine | Multi-line docstring summary should start at the first line |  |  |
-| D213 | MultiLineSummarySecondLine | Multi-line docstring summary should start at the second line |  |  |
-| D214 | SectionNotOverIndented | Section is over-indented ("Returns") |  |  |
-| D215 | SectionUnderlineNotOverIndented | Section underline is over-indented ("Returns") |  |  |
-| D300 | UsesTripleQuotes | Use """triple double quotes""" |  |  |
-| D400 | EndsInPeriod | First line should end with a period |  |  |
-| D402 | NoSignature | First line should not be the function's 'signature' |  |  |
-| D403 | FirstLineCapitalized | First word of the first line should be properly capitalized |  |  |
-| D404 | NoThisPrefix | First word of the docstring should not be `This` |  |  |
-| D405 | CapitalizeSectionName | Section name should be properly capitalized ("returns") |  |  |
-| D406 | NewLineAfterSectionName | Section name should end with a newline ("Returns") |  |  |
-| D407 | DashedUnderlineAfterSection | Missing dashed underline after section ("Returns") |  |  |
-| D408 | SectionUnderlineAfterName | Section underline should be in the line following the section's name ("Returns") |  |  |
-| D409 | SectionUnderlineMatchesSectionLength | Section underline should match the length of its name ("Returns") |  |  |
-| D410 | BlankLineAfterSection | Missing blank line after section ("Returns") |  |  |
-| D411 | BlankLineBeforeSection | Missing blank line before section ("Returns") |  |  |
-| D412 | NoBlankLinesBetweenHeaderAndContent | No blank lines allowed between a section header and its content ("Returns") |  |  |
-| D413 | BlankLineAfterLastSection | Missing blank line after last section ("Returns") |  |  |
-| D414 | NonEmptySection | Section has no content ("Returns") |  |  |
-| D415 | EndsInPunctuation | First line should end with a period, question mark, or exclamation point |  |  |
-| D417 | DocumentAllArguments | Missing argument descriptions in the docstring: `x`, `y` |  |  |
-| D418 | SkipDocstring | Function decorated with @overload shouldn't contain a docstring |  |  |
-| D419 | NonEmpty | Docstring is empty |  |  |
-| M001 | UnusedNOQA | Unused `noqa` directive |  | 🛠 |
+### Pyflakes

-## Integrations
+| Code | Name | Message | Fix |
+| ---- | ---- | ------- | --- |
+| F401 | UnusedImport | `...` imported but unused | 🛠 |
+| F402 | ImportShadowedByLoopVar | Import `...` from line 1 shadowed by loop variable |  |
+| F403 | ImportStarUsed | `from ... import *` used; unable to detect undefined names |  |
+| F404 | LateFutureImport | `from __future__` imports must occur at the beginning of the file |  |
+| F405 | ImportStarUsage | `...` may be undefined, or defined from star imports: `...` |  |
+| F406 | ImportStarNotPermitted | `from ... import *` only allowed at module level |  |
+| F407 | FutureFeatureNotDefined | Future feature `...` is not defined |  |
+| F541 | FStringMissingPlaceholders | f-string without any placeholders |  |
+| F601 | MultiValueRepeatedKeyLiteral | Dictionary key literal repeated |  |
+| F602 | MultiValueRepeatedKeyVariable | Dictionary key `...` repeated |  |
+| F621 | ExpressionsInStarAssignment | Too many expressions in star-unpacking assignment |  |
+| F622 | TwoStarredExpressions | Two starred expressions in assignment |  |
+| F631 | AssertTuple | Assert test is a non-empty tuple, which is always `True` |  |
+| F632 | IsLiteral | Use `==` and `!=` to compare constant literals |  |
+| F633 | InvalidPrintSyntax | Use of `>>` is invalid with `print` function |  |
+| F634 | IfTuple | If test is a tuple, which is always `True` |  |
+| F701 | BreakOutsideLoop | `break` outside loop |  |
+| F702 | ContinueOutsideLoop | `continue` not properly in loop |  |
+| F704 | YieldOutsideFunction | `yield` or `yield from` statement outside of a function/method |  |
+| F706 | ReturnOutsideFunction | `return` statement outside of a function/method |  |
+| F707 | DefaultExceptNotLast | An `except:` block as not the last exception handler |  |
+| F722 | ForwardAnnotationSyntaxError | Syntax error in forward annotation: `...` |  |
+| F821 | UndefinedName | Undefined name `...` |  |
+| F822 | UndefinedExport | Undefined name `...` in `__all__` |  |
+| F823 | UndefinedLocal | Local variable `...` referenced before assignment |  |
+| F831 | DuplicateArgumentName | Duplicate argument name in function definition |  |
+| F841 | UnusedVariable | Local variable `...` is assigned to but never used |  |
+| F901 | RaiseNotImplemented | `raise NotImplemented` should be `raise NotImplementedError` |  |
+
+### pycodestyle
+
+| Code | Name | Message | Fix |
+| ---- | ---- | ------- | --- |
+| E402 | ModuleImportNotAtTopOfFile | Module level import not at top of file |  |
+| E501 | LineTooLong | Line too long (89 > 88 characters) |  |
+| E711 | NoneComparison | Comparison to `None` should be `cond is None` |  |
+| E712 | TrueFalseComparison | Comparison to `True` should be `cond is True` |  |
+| E713 | NotInTest | Test for membership should be `not in` |  |
+| E714 | NotIsTest | Test for object identity should be `is not` |  |
+| E721 | TypeComparison | Do not compare types, use `isinstance()` |  |
+| E722 | DoNotUseBareExcept | Do not use bare `except` |  |
+| E731 | DoNotAssignLambda | Do not assign a lambda expression, use a def |  |
+| E741 | AmbiguousVariableName | Ambiguous variable name: `...` |  |
+| E742 | AmbiguousClassName | Ambiguous class name: `...` |  |
+| E743 | AmbiguousFunctionName | Ambiguous function name: `...` |  |
+| E902 | IOError | IOError: `...` |  |
+| E999 | SyntaxError | SyntaxError: `...` |  |
+| W292 | NoNewLineAtEndOfFile | No newline at end of file |  |
+
+### pydocstyle
+
+| Code | Name | Message | Fix |
+| ---- | ---- | ------- | --- |
+| D100 | PublicModule | Missing docstring in public module |  |
+| D101 | PublicClass | Missing docstring in public class |  |
+| D102 | PublicMethod | Missing docstring in public method |  |
+| D103 | PublicFunction | Missing docstring in public function |  |
+| D104 | PublicPackage | Missing docstring in public package |  |
+| D105 | MagicMethod | Missing docstring in magic method |  |
+| D106 | PublicNestedClass | Missing docstring in public nested class |  |
+| D107 | PublicInit | Missing docstring in `__init__` |  |
+| D200 | FitsOnOneLine | One-line docstring should fit on one line |  |
+| D201 | NoBlankLineBeforeFunction | No blank lines allowed before function docstring (found 1) | 🛠 |
+| D202 | NoBlankLineAfterFunction | No blank lines allowed after function docstring (found 1) | 🛠 |
+| D203 | OneBlankLineBeforeClass | 1 blank line required before class docstring | 🛠 |
+| D204 | OneBlankLineAfterClass | 1 blank line required after class docstring | 🛠 |
+| D205 | NoBlankLineAfterSummary | 1 blank line required between summary line and description | 🛠 |
+| D206 | IndentWithSpaces | Docstring should be indented with spaces, not tabs |  |
+| D207 | NoUnderIndentation | Docstring is under-indented |  |
+| D208 | NoOverIndentation | Docstring is over-indented |  |
+| D209 | NewLineAfterLastParagraph | Multi-line docstring closing quotes should be on a separate line | 🛠 |
+| D210 | NoSurroundingWhitespace | No whitespaces allowed surrounding docstring text | 🛠 |
+| D211 | NoBlankLineBeforeClass | No blank lines allowed before class docstring | 🛠 |
+| D212 | MultiLineSummaryFirstLine | Multi-line docstring summary should start at the first line |  |
+| D213 | MultiLineSummarySecondLine | Multi-line docstring summary should start at the second line |  |
+| D214 | SectionNotOverIndented | Section is over-indented ("Returns") |  |
+| D215 | SectionUnderlineNotOverIndented | Section underline is over-indented ("Returns") |  |
+| D300 | UsesTripleQuotes | Use """triple double quotes""" |  |
+| D400 | EndsInPeriod | First line should end with a period |  |
+| D402 | NoSignature | First line should not be the function's 'signature' |  |
+| D403 | FirstLineCapitalized | First word of the first line should be properly capitalized |  |
+| D404 | NoThisPrefix | First word of the docstring should not be `This` |  |
+| D405 | CapitalizeSectionName | Section name should be properly capitalized ("returns") |  |
+| D406 | NewLineAfterSectionName | Section name should end with a newline ("Returns") |  |
+| D407 | DashedUnderlineAfterSection | Missing dashed underline after section ("Returns") |  |
+| D408 | SectionUnderlineAfterName | Section underline should be in the line following the section's name ("Returns") |  |
+| D409 | SectionUnderlineMatchesSectionLength | Section underline should match the length of its name ("Returns") |  |
+| D410 | BlankLineAfterSection | Missing blank line after section ("Returns") | 🛠 |
+| D411 | BlankLineBeforeSection | Missing blank line before section ("Returns") |  |
+| D412 | NoBlankLinesBetweenHeaderAndContent | No blank lines allowed between a section header and its content ("Returns") |  |
+| D413 | BlankLineAfterLastSection | Missing blank line after last section ("Returns") | 🛠 |
+| D414 | NonEmptySection | Section has no content ("Returns") |  |
+| D415 | EndsInPunctuation | First line should end with a period, question mark, or exclamation point |  |
+| D416 | SectionNameEndsInColon | Section name should end with a colon ("Returns") |  |
+| D417 | DocumentAllArguments | Missing argument descriptions in the docstring: `x`, `y` |  |
+| D418 | SkipDocstring | Function decorated with @overload shouldn't contain a docstring |  |
+| D419 | NonEmpty | Docstring is empty |  |
+
+### pyupgrade
+
+| Code | Name | Message | Fix |
+| ---- | ---- | ------- | --- |
+| U001 | UselessMetaclassType | `__metaclass__ = type` is implied | 🛠 |
+| U002 | UnnecessaryAbspath | `abspath(__file__)` is unnecessary in Python 3.9 and later | 🛠 |
+| U003 | TypeOfPrimitive | Use `str` instead of `type(...)` | 🛠 |
+| U004 | UselessObjectInheritance | Class `...` inherits from object | 🛠 |
+| U005 | DeprecatedUnittestAlias | `assertEquals` is deprecated, use `assertEqual` instead | 🛠 |
+| U006 | UsePEP585Annotation | Use `list` instead of `List` for type annotations | 🛠 |
+| U007 | UsePEP604Annotation | Use `X \| Y` for type annotations | 🛠 |
+| U008 | SuperCallWithParameters | Use `super()` instead of `super(__class__, self)` | 🛠 |
+
+### pep8-naming
+
+| Code | Name | Message | Fix |
+| ---- | ---- | ------- | --- |
+| N801 | InvalidClassName | Class name `...` should use CapWords convention  |  |
+| N802 | InvalidFunctionName | Function name `...` should be lowercase |  |
+| N803 | InvalidArgumentName | Argument name `...` should be lowercase |  |
+| N804 | InvalidFirstArgumentNameForClassMethod | First argument of a class method should be named `cls` |  |
+| N805 | InvalidFirstArgumentNameForMethod | First argument of a method should be named `self` |  |
+
+### flake8-comprehensions
+
+| Code | Name | Message | Fix |
+| ---- | ---- | ------- | --- |
+| C400 | UnnecessaryGeneratorList | Unnecessary generator (rewrite as a `list` comprehension) |  |
+| C401 | UnnecessaryGeneratorSet | Unnecessary generator (rewrite as a `set` comprehension) |  |
+| C402 | UnnecessaryGeneratorDict | Unnecessary generator (rewrite as a `dict` comprehension) |  |
+| C403 | UnnecessaryListComprehensionSet | Unnecessary `list` comprehension (rewrite as a `set` comprehension) |  |
+| C404 | UnnecessaryListComprehensionDict | Unnecessary `list` comprehension (rewrite as a `dict` comprehension) |  |
+| C405 | UnnecessaryLiteralSet | Unnecessary `(list\|tuple)` literal (rewrite as a `set` literal) |  |
+| C406 | UnnecessaryLiteralDict | Unnecessary `(list\|tuple)` literal (rewrite as a `dict` literal) |  |
+| C408 | UnnecessaryCollectionCall | Unnecessary `(dict\|list\|tuple)` call (rewrite as a literal) |  |
+| C409 | UnnecessaryLiteralWithinTupleCall | Unnecessary `(list\|tuple)` literal passed to `tuple()` (remove the outer call to `tuple()`) |  |
+| C410 | UnnecessaryLiteralWithinListCall | Unnecessary `(list\|tuple)` literal passed to `list()` (rewrite as a `list` literal) |  |
+| C411 | UnnecessaryListCall | Unnecessary `list` call (remove the outer call to `list()`) |  |
+| C413 | UnnecessaryCallAroundSorted | Unnecessary `(list\|reversed)` call around `sorted()` |  |
+| C414 | UnnecessaryDoubleCastOrProcess | Unnecessary `(list\|reversed\|set\|sorted\|tuple)` call within `(list\|set\|sorted\|tuple)()` |  |
+| C415 | UnnecessarySubscriptReversal | Unnecessary subscript reversal of iterable within `(reversed\|set\|sorted)()` |  |
+| C416 | UnnecessaryComprehension |  Unnecessary `(list\|set)` comprehension (rewrite using `(list\|set)()`) |  |
+| C417 | UnnecessaryMap | Unnecessary `map` usage (rewrite using a `(list\|set\|dict)` comprehension) |  |
+
+### flake8-bugbear
+
+| Code | Name | Message | Fix |
+| ---- | ---- | ------- | --- |
+| B011 | DoNotAssertFalse | Do not `assert False` (`python -O` removes these calls), raise `AssertionError()` | 🛠 |
+| B014 | DuplicateHandlerException | Exception handler with duplicate exception: `ValueError` | 🛠 |
+| B025 | DuplicateTryBlockException | try-except block with duplicate exception `Exception` |  |
+
+### flake8-builtins
+
+| Code | Name | Message | Fix |
+| ---- | ---- | ------- | --- |
+| A001 | BuiltinVariableShadowing | Variable `...` is shadowing a python builtin |  |
+| A002 | BuiltinArgumentShadowing | Argument `...` is shadowing a python builtin |  |
+| A003 | BuiltinAttributeShadowing | Class attribute `...` is shadowing a python builtin |  |
+
+### flake8-print
+
+| Code | Name | Message | Fix |
+| ---- | ---- | ------- | --- |
+| T201 | PrintFound | `print` found | 🛠 |
+| T203 | PPrintFound | `pprint` found | 🛠 |
+
+### Meta rules
+
+| Code | Name | Message | Fix |
+| ---- | ---- | ------- | --- |
+| M001 | UnusedNOQA | Unused `noqa` directive | 🛠 |
+
+## Editor Integrations

 ### PyCharm

-ruff can be installed as an [External Tool](https://www.jetbrains.com/help/pycharm/configuring-third-party-tools.html)
+Ruff can be installed as an [External Tool](https://www.jetbrains.com/help/pycharm/configuring-third-party-tools.html)
 in PyCharm. Open the Preferences pane, then navigate to "Tools", then "External Tools". From there,
 add a new tool with the following configuration:

-![Install ruff as an External Tool](https://user-images.githubusercontent.com/1309177/193155720-336e43f0-1a8d-46b4-bc12-e60f9ae01f7e.png)
+![Install Ruff as an External Tool](https://user-images.githubusercontent.com/1309177/193155720-336e43f0-1a8d-46b4-bc12-e60f9ae01f7e.png)

-ruff should then appear as a runnable action:
+Ruff should then appear as a runnable action:

-![ruff as a runnable action](https://user-images.githubusercontent.com/1309177/193156026-732b0aaf-3dd9-4549-9b4d-2de6d2168a33.png)
+![Ruff as a runnable action](https://user-images.githubusercontent.com/1309177/193156026-732b0aaf-3dd9-4549-9b4d-2de6d2168a33.png)

 ### GitHub Actions

-GitHub Actions has everything you need to run ruff out-of-the-box:
+GitHub Actions has everything you need to run Ruff out-of-the-box:

 ```yaml
 name: CI
@@ -388,13 +433,175 @@ jobs:
        run: |
          python -m pip install --upgrade pip
          pip install ruff
-      - name: Run ruff
+      - name: Run Ruff
        run: ruff .
 ```

+## FAQ
+
+### Is Ruff compatible with Black?
+
+Yes. Ruff is compatible with [Black](https://github.com/psf/black) out-of-the-box, as long as
+the `line-length` setting is consistent between the two.
+
+As a project, Ruff is designed to be used alongside Black and, as such, will defer implementing
+stylistic lint rules that are obviated by autoformatting.
+
+### How does Ruff compare to Flake8?
+
+Ruff can be used as a (near) drop-in replacement for Flake8 when used (1) without or with a small
+number of plugins, (2) alongside Black, and (3) on Python 3 code.
+
+Under those conditions Ruff is missing 14 rules related to string `.format` calls, 1 rule related
+to docstring parsing, and 1 rule related to redefined variables.
+
+Ruff re-implements some of the most popular Flake8 plugins and related code quality tools natively,
+including:
+
+- [`pydocstyle`](https://pypi.org/project/pydocstyle/)
+- [`yesqa`](https://github.com/asottile/yesqa)
+- [`flake8-docstrings`](https://pypi.org/project/flake8-docstrings/)
+- [`flake8-builtins`](https://pypi.org/project/flake8-builtins/)
+- [`flake8-super`](https://pypi.org/project/flake8-super/)
+- [`flake8-print`](https://pypi.org/project/flake8-print/)
+- [`flake8-comprehensions`](https://pypi.org/project/flake8-comprehensions/)
+- [`flake8-bugbear`](https://pypi.org/project/flake8-bugbear/) (3/32)
+- [`pyupgrade`](https://pypi.org/project/pyupgrade/) (8/34)
+- [`autoflake`](https://pypi.org/project/autoflake/) (1/7)
+
+Beyond rule-set parity, Ruff suffers from the following limitations vis-à-vis Flake8:
+
+1. Ruff does not yet support a few Python 3.9 and 3.10 language features, including structural
+   pattern matching and parenthesized context managers.
+2. Flake8 has a plugin architecture and supports writing custom lint rules. (To date, popular Flake8
+   plugins have been re-implemented within Ruff directly.)
+
+### Which tools does Ruff replace?
+
+Today, Ruff can be used to replace Flake8 when used with any of the following plugins:
+
+- [`flake8-docstrings`](https://pypi.org/project/flake8-docstrings/)
+- [`flake8-builtins`](https://pypi.org/project/flake8-builtins/)
+- [`flake8-super`](https://pypi.org/project/flake8-super/)
+- [`flake8-print`](https://pypi.org/project/flake8-print/)
+- [`flake8-comprehensions`](https://pypi.org/project/flake8-comprehensions/)
+- [`flake8-bugbear`](https://pypi.org/project/flake8-bugbear/) (3/32)
+
+Ruff also implements the functionality that you get from [`yesqa`](https://github.com/asottile/yesqa),
+and a subset of the rules implemented in [`pyupgrade`](https://pypi.org/project/pyupgrade/) (8/34).
+
+If you're looking to use Ruff, but rely on an unsupported Flake8 plugin, free to file an Issue.
+
+### Do I need to install Rust to use Ruff?
+
+Nope! Ruff is available as [`ruff`](https://pypi.org/project/ruff/) on PyPI:
+
+```shell
+pip install ruff
+```
+
+Ruff ships with wheels for all major platforms, which enables `pip` to install Ruff without relying
+on Rust at all.
+
+### Can I write my own plugins for Ruff?
+
+Ruff does not yet support third-party plugins, though a plugin system is within-scope for the
+project. See [#283](https://github.com/charliermarsh/ruff/issues/2830) for more.
+
+### Does Ruff support NumPy- or Google-style docstrings?
+
+Yes! To enable a specific docstring convention, start by enabling all `pydocstyle` error codes, and
+then selectively disabling based on your [preferred convention](https://www.pydocstyle.org/en/latest/error_codes.html#default-conventions).
+
+For example, if you're coming from `flake8-docstrings`, the following configuration is equivalent to
+`--docstring-convention numpy`:
+
+```toml
+[tool.ruff]
+extend-select = [
+    "D100",
+    "D101",
+    "D102",
+    "D103",
+    "D104",
+    "D105",
+    "D106",
+    "D200",
+    "D201",
+    "D202",
+    "D204",
+    "D205",
+    "D206",
+    "D207",
+    "D208",
+    "D209",
+    "D210",
+    "D211",
+    "D214",
+    "D215",
+    "D300",
+    "D400",
+    "D402",
+    "D403",
+    "D404",
+    "D405",
+    "D406",
+    "D407",
+    "D408",
+    "D409",
+    "D410",
+    "D411",
+    "D412",
+    "D413",
+    "D418",
+    "D419",
+]
+```
+
+Similarly, the following is equivalent to `--docstring-convention google`:
+
+```toml
+[tool.ruff]
+extend-select = [
+    "D100",
+    "D101",
+    "D102",
+    "D103",
+    "D104",
+    "D105",
+    "D106",
+    "D107",
+    "D200",
+    "D201",
+    "D202",
+    "D205",
+    "D206",
+    "D207",
+    "D208",
+    "D209",
+    "D210",
+    "D211",
+    "D212",
+    "D214",
+    "D300",
+    "D402",
+    "D403",
+    "D405",
+    "D410",
+    "D411",
+    "D412",
+    "D414",
+    "D415",
+    "D416",
+    "D417",
+    "D418",
+    "D419",
+]
+```
+
 ## Development

-ruff is written in Rust (1.63.0). You'll need to install the [Rust toolchain](https://www.rust-lang.org/tools/install)
+Ruff is written in Rust (1.63.0). You'll need to install the [Rust toolchain](https://www.rust-lang.org/tools/install)
 for development.

 Assuming you have `cargo` installed, you can run:
@@ -406,13 +613,13 @@ cargo clippy
 cargo test
 ```

-## Deployment
+## Releases

-ruff is distributed on [PyPI](https://pypi.org/project/ruff/), and published via [`maturin`](https://github.com/PyO3/maturin).
+Ruff is distributed on [PyPI](https://pypi.org/project/ruff/), and published via [`maturin`](https://github.com/PyO3/maturin).

 See: `.github/workflows/release.yaml`.

-## Benchmarking
+## Benchmarks

 First, clone [CPython](https://github.com/python/cpython). It's a large and diverse Python codebase,
 which makes it a good target for benchmarking.
@@ -489,9 +696,9 @@ hyperfine --ignore-failure --warmup 5 \

 In order, these evaluate:

- ruff
+- Ruff
 - Pylint
- PyFlakes
+- Pyflakes
 - autoflake
 - pycodestyle
 - Flake8
--- a/examples/generate_rules_table.rs
+++ b/examples/generate_rules_table.rs
@@ -1,26 +1,29 @@
-/// Generate a Markdown-compatible table of supported lint rules.
+//! Generate a Markdown-compatible table of supported lint rules.
+
 use strum::IntoEnumIterator;

-use ruff::checks::{CheckCode, DEFAULT_CHECK_CODES};
+use ruff::checks::{CheckCategory, CheckCode};

 fn main() {
-    println!("| Code | Name | Message |     |     |");
-    println!("| ---- | ---- | ------- | --- | --- |");
-    for check_code in CheckCode::iter() {
-        let check_kind = check_code.kind();
-        let default_token = if DEFAULT_CHECK_CODES.contains(&check_code) {
-            "✅"
-        } else {
-            ""
-        };
-        let fix_token = if check_kind.fixable() { "🛠" } else { "" };
-        println!(
-            "| {} | {} | {} | {} | {} |",
-            check_kind.code().as_ref(),
-            check_kind.as_ref(),
-            check_kind.body().replace("|", r"\|"),
-            default_token,
-            fix_token
-        );
+    for check_category in CheckCategory::iter() {
+        println!("### {}", check_category.title());
+        println!();
+
+        println!("| Code | Name | Message | Fix |");
+        println!("| ---- | ---- | ------- | --- |");
+        for check_code in CheckCode::iter() {
+            if check_code.category() == check_category {
+                let check_kind = check_code.kind();
+                let fix_token = if check_kind.fixable() { "🛠" } else { "" };
+                println!(
+                    "| {} | {} | {} | {} |",
+                    check_kind.code().as_ref(),
+                    check_kind.as_ref(),
+                    check_kind.body().replace("|", r"\|"),
+                    fix_token
+                );
+            }
+        }
+        println!();
    }
 }
--- a/examples/print_ast.rs
+++ b/examples/print_ast.rs
@@ -1,4 +1,5 @@
-/// Print the AST for a given Python file.
+//! Print the AST for a given Python file.
+
 use std::path::PathBuf;

 use anyhow::Result;
--- a/examples/print_tokens.rs
+++ b/examples/print_tokens.rs
@@ -1,4 +1,5 @@
-/// Print the token stream for a given Python file.
+//! Print the token stream for a given Python file.
+
 use std::path::PathBuf;

 use anyhow::Result;
--- a/resources/test/fixtures/C417.py
+++ b/resources/test/fixtures/C417.py
@@ -0,0 +1,6 @@
+nums = [1, 2, 3]
+map(lambda x: x + 1, nums)
+map(lambda x: str(x), nums)
+list(map(lambda x: x * 2, nums))
+set(map(lambda x: x % 2 == 0, nums))
+dict(map(lambda v: (v, v**2), nums))
--- a/resources/test/fixtures/F401_0.py
+++ b/resources/test/fixtures/F401_0.py
@@ -61,7 +61,7 @@ Y = TypeVar("Y", bound="Dict")
 Z = TypeVar("Z", "List", "Set")

 a = list["Fruit"]
-b = Union["Nut", None]
+b = Union["""Nut""", None]
 c = cast("Vegetable", b)

 Field = lambda default=MISSING: field(default=default)
--- a/resources/test/fixtures/N801.py
+++ b/resources/test/fixtures/N801.py
@@ -0,0 +1,34 @@
+class bad:
+    pass
+
+
+class _bad:
+    pass
+
+
+class bad_class:
+    pass
+
+
+class Bad_Class:
+    pass
+
+
+class BAD_CLASS:
+    pass
+
+
+class Good:
+    pass
+
+
+class _Good:
+    pass
+
+
+class GoodClass:
+    pass
+
+
+class GOOD:
+    pass
--- a/resources/test/fixtures/N802.py
+++ b/resources/test/fixtures/N802.py
@@ -0,0 +1,26 @@
+def Bad():
+    pass
+
+
+def _Bad():
+    pass
+
+
+def BAD():
+    pass
+
+
+def BAD_FUNC():
+    pass
+
+
+def good():
+    pass
+
+
+def _good():
+    pass
+
+
+def good_func():
+    pass
--- a/resources/test/fixtures/N803.py
+++ b/resources/test/fixtures/N803.py
@@ -0,0 +1,7 @@
+def func(a, A):
+    return a, A
+
+
+class Class:
+    def method(self, a, A):
+        return a, A
--- a/resources/test/fixtures/N804.py
+++ b/resources/test/fixtures/N804.py
@@ -0,0 +1,19 @@
+class Class:
+    @classmethod
+    def bad_class_method(this):
+        pass
+
+    @classmethod
+    def good_class_method(cls):
+        pass
+
+    def method(self):
+        pass
+
+    @staticmethod
+    def static_method(x):
+        return x
+
+
+def func(x):
+    return x
--- a/resources/test/fixtures/N805.py
+++ b/resources/test/fixtures/N805.py
@@ -0,0 +1,26 @@
+import random
+
+
+class Class:
+    def bad_method(this):
+        pass
+
+    if random.random(0, 2) == 0:
+
+        def extra_bad_method(this):
+            pass
+
+    def good_method(self):
+        pass
+
+    @classmethod
+    def class_method(cls):
+        pass
+
+    @staticmethod
+    def static_method(x):
+        return x
+
+
+def func(x):
+    return x
--- a/resources/test/fixtures/canonical_google_examples.py
+++ b/resources/test/fixtures/canonical_google_examples.py
@@ -0,0 +1,108 @@
+"""A one line summary of the module or program, terminated by a period.
+
+Leave one blank line.  The rest of this docstring should contain an
+overall description of the module or program.  Optionally, it may also
+contain a brief description of exported classes and functions and/or usage
+examples.
+
+  Typical usage example:
+
+  foo = ClassFoo()
+  bar = foo.FunctionBar()
+"""
+# above: "2.8.2 Modules" section example
+# https://google.github.io/styleguide/pyguide.html#382-modules
+
+# Examples from the official "Google Python Style Guide" documentation:
+#     * As HTML: https://google.github.io/styleguide/pyguide.html
+#     * Source Markdown:
+#         https://github.com/google/styleguide/blob/gh-pages/pyguide.md
+
+import os
+from .expected import Expectation
+
+expectation = Expectation()
+expect = expectation.expect
+
+# module docstring expected violations:
+expectation.expected.add((
+    os.path.normcase(__file__),
+    "D213: Multi-line docstring summary should start at the second line"))
+
+
+# "3.8.3 Functions and Methods" section example
+# https://google.github.io/styleguide/pyguide.html#383-functions-and-methods
+@expect("D213: Multi-line docstring summary should start at the second line",
+        arg_count=3)
+@expect("D401: First line should be in imperative mood "
+        "(perhaps 'Fetch', not 'Fetches')", arg_count=3)
+@expect("D406: Section name should end with a newline "
+        "('Raises', not 'Raises:')", arg_count=3)
+@expect("D406: Section name should end with a newline "
+        "('Returns', not 'Returns:')", arg_count=3)
+@expect("D407: Missing dashed underline after section ('Raises')", arg_count=3)
+@expect("D407: Missing dashed underline after section ('Returns')",
+        arg_count=3)
+@expect("D413: Missing blank line after last section ('Raises')", arg_count=3)
+def fetch_bigtable_rows(big_table, keys, other_silly_variable=None):
+    """Fetches rows from a Bigtable.
+
+    Retrieves rows pertaining to the given keys from the Table instance
+    represented by big_table.  Silly things may happen if
+    other_silly_variable is not None.
+
+    Args:
+        big_table: An open Bigtable Table instance.
+        keys: A sequence of strings representing the key of each table row
+            to fetch.
+        other_silly_variable: Another optional variable, that has a much
+            longer name than the other args, and which does nothing.
+
+    Returns:
+        A dict mapping keys to the corresponding table row data
+        fetched. Each row is represented as a tuple of strings. For
+        example:
+
+        {'Serak': ('Rigel VII', 'Preparer'),
+         'Zim': ('Irk', 'Invader'),
+         'Lrrr': ('Omicron Persei 8', 'Emperor')}
+
+        If a key from the keys argument is missing from the dictionary,
+        then that row was not found in the table.
+
+    Raises:
+        IOError: An error occurred accessing the bigtable.Table object.
+    """
+
+
+# "3.8.4 Classes" section example
+# https://google.github.io/styleguide/pyguide.html#384-classes
+@expect("D203: 1 blank line required before class docstring (found 0)")
+@expect("D213: Multi-line docstring summary should start at the second line")
+@expect("D406: Section name should end with a newline "
+        "('Attributes', not 'Attributes:')")
+@expect("D407: Missing dashed underline after section ('Attributes')")
+@expect("D413: Missing blank line after last section ('Attributes')")
+class SampleClass:
+    """Summary of class here.
+
+    Longer class information....
+    Longer class information....
+
+    Attributes:
+        likes_spam: A boolean indicating if we like SPAM or not.
+        eggs: An integer count of the eggs we have laid.
+    """
+
+    @expect("D401: First line should be in imperative mood "
+            "(perhaps 'Init', not 'Inits')", arg_count=2)
+    def __init__(self, likes_spam=False):
+        """Inits SampleClass with blah."""
+        if self:  # added to avoid NameError when run via @expect decorator
+            self.likes_spam = likes_spam
+            self.eggs = 0
+
+    @expect("D401: First line should be in imperative mood "
+            "(perhaps 'Perform', not 'Performs')", arg_count=1)
+    def public_method(self):
+        """Performs operation blah."""
--- a/scripts/.flake8
+++ b/scripts/.flake8
@@ -0,0 +1,19 @@
+[flake8]
+exclude =
+    # Defaults
+    .svn,
+    CVS,
+    .bzr,
+    .hg,
+    .git,
+    __pycache__,
+    .tox,
+    .idea,
+    .mypy_cache,
+    .venv,
+    node_modules,
+    # Custom
+    _state_machine.py,
+    test_fstring.py,
+    bad_coding2.py,
+    badsyntax_*.py
--- a/src/ast/checkers.rs
+++ b/src/ast/checkers.rs
@@ -118,7 +118,7 @@ pub fn do_not_assign_lambda(value: &Expr, location: Range) -> Option<Check> {
 }

 /// Check UselessMetaclassType compliance.
-pub fn useless_metaclass_type(targets: &Vec<Expr>, value: &Expr, location: Range) -> Option<Check> {
+pub fn useless_metaclass_type(targets: &[Expr], value: &Expr, location: Range) -> Option<Check> {
    if targets.len() == 1 {
        if let ExprKind::Name { id, .. } = targets.first().map(|expr| &expr.node).unwrap() {
            if id == "__metaclass__" {
@@ -134,7 +134,7 @@ pub fn useless_metaclass_type(targets: &Vec<Expr>, value: &Expr, location: Range
 }

 /// Check UnnecessaryAbspath compliance.
-pub fn unnecessary_abspath(func: &Expr, args: &Vec<Expr>, location: Range) -> Option<Check> {
+pub fn unnecessary_abspath(func: &Expr, args: &[Expr], location: Range) -> Option<Check> {
    // Validate the arguments.
    if args.len() == 1 {
        if let ExprKind::Name { id, .. } = &args[0].node {
@@ -190,7 +190,7 @@ impl Primitive {
 }

 /// Check TypeOfPrimitive compliance.
-pub fn type_of_primitive(func: &Expr, args: &Vec<Expr>, location: Range) -> Option<Check> {
+pub fn type_of_primitive(func: &Expr, args: &[Expr], location: Range) -> Option<Check> {
    // Validate the arguments.
    if args.len() == 1 {
        match &func.node {
@@ -279,7 +279,7 @@ pub fn useless_object_inheritance(name: &str, bases: &[Expr], scope: &Scope) ->
 }

 /// Check DefaultExceptNotLast compliance.
-pub fn default_except_not_last(handlers: &Vec<Excepthandler>) -> Option<Check> {
+pub fn default_except_not_last(handlers: &[Excepthandler]) -> Option<Check> {
    for (idx, handler) in handlers.iter().enumerate() {
        let ExcepthandlerKind::ExceptHandler { type_, .. } = &handler.node;
        if type_.is_none() && idx < handlers.len() - 1 {
@@ -370,7 +370,7 @@ fn convert_to_value(expr: &Expr) -> Option<DictionaryKey> {

 /// Check MultiValueRepeatedKeyLiteral and MultiValueRepeatedKeyVariable compliance.
 pub fn repeated_keys(
-    keys: &Vec<Expr>,
+    keys: &[Expr],
    check_repeated_literals: bool,
    check_repeated_variables: bool,
    locator: &dyn CheckLocator,
@@ -411,8 +411,8 @@ pub fn repeated_keys(
 /// Check TrueFalseComparison and NoneComparison compliance.
 pub fn literal_comparisons(
    left: &Expr,
-    ops: &Vec<Cmpop>,
-    comparators: &Vec<Expr>,
+    ops: &[Cmpop],
+    comparators: &[Expr],
    check_none_comparisons: bool,
    check_true_false_comparisons: bool,
    locator: &dyn CheckLocator,
@@ -540,12 +540,7 @@ fn is_constant_non_singleton(expr: &Expr) -> bool {
 }

 /// Check IsLiteral compliance.
-pub fn is_literal(
-    left: &Expr,
-    ops: &Vec<Cmpop>,
-    comparators: &Vec<Expr>,
-    location: Range,
-) -> Vec<Check> {
+pub fn is_literal(left: &Expr, ops: &[Cmpop], comparators: &[Expr], location: Range) -> Vec<Check> {
    let mut checks: Vec<Check> = vec![];

    let mut left = left;
@@ -562,7 +557,7 @@ pub fn is_literal(
 }

 /// Check TypeComparison compliance.
-pub fn type_comparison(ops: &Vec<Cmpop>, comparators: &Vec<Expr>, location: Range) -> Vec<Check> {
+pub fn type_comparison(ops: &[Cmpop], comparators: &[Expr], location: Range) -> Vec<Check> {
    let mut checks: Vec<Check> = vec![];

    for (op, right) in izip!(ops, comparators) {
@@ -734,7 +729,7 @@ pub fn builtin_shadowing(name: &str, location: Range, node_type: ShadowingType)

 // flake8-comprehensions
 /// Check `list(generator)` compliance.
-pub fn unnecessary_generator_list(expr: &Expr, func: &Expr, args: &Vec<Expr>) -> Option<Check> {
+pub fn unnecessary_generator_list(expr: &Expr, func: &Expr, args: &[Expr]) -> Option<Check> {
    if args.len() == 1 {
        if let ExprKind::Name { id, .. } = &func.node {
            if id == "list" {
@@ -751,13 +746,13 @@ pub fn unnecessary_generator_list(expr: &Expr, func: &Expr, args: &Vec<Expr>) ->
 }

 /// Check `set(generator)` compliance.
-pub fn unnecessary_generator_set(expr: &Expr, func: &Expr, args: &Vec<Expr>) -> Option<Check> {
+pub fn unnecessary_generator_set(expr: &Expr, func: &Expr, args: &[Expr]) -> Option<Check> {
    if args.len() == 1 {
        if let ExprKind::Name { id, .. } = &func.node {
            if id == "set" {
                if let ExprKind::GeneratorExp { .. } = &args[0].node {
                    return Some(Check::new(
-                        CheckKind::UnnecessaryGeneratorList,
+                        CheckKind::UnnecessaryGeneratorSet,
                        Range::from_located(expr),
                    ));
                }
@@ -768,7 +763,7 @@ pub fn unnecessary_generator_set(expr: &Expr, func: &Expr, args: &Vec<Expr>) ->
 }

 /// Check `dict((x, y) for x, y in iterable)` compliance.
-pub fn unnecessary_generator_dict(expr: &Expr, func: &Expr, args: &Vec<Expr>) -> Option<Check> {
+pub fn unnecessary_generator_dict(expr: &Expr, func: &Expr, args: &[Expr]) -> Option<Check> {
    if args.len() == 1 {
        if let ExprKind::Name { id, .. } = &func.node {
            if id == "dict" {
@@ -776,7 +771,7 @@ pub fn unnecessary_generator_dict(expr: &Expr, func: &Expr, args: &Vec<Expr>) ->
                    match &elt.node {
                        ExprKind::Tuple { elts, .. } if elts.len() == 2 => {
                            return Some(Check::new(
-                                CheckKind::UnnecessaryListComprehensionDict,
+                                CheckKind::UnnecessaryGeneratorDict,
                                Range::from_located(expr),
                            ));
                        }
@@ -793,7 +788,7 @@ pub fn unnecessary_generator_dict(expr: &Expr, func: &Expr, args: &Vec<Expr>) ->
 pub fn unnecessary_list_comprehension_set(
    expr: &Expr,
    func: &Expr,
-    args: &Vec<Expr>,
+    args: &[Expr],
 ) -> Option<Check> {
    if args.len() == 1 {
        if let ExprKind::Name { id, .. } = &func.node {
@@ -814,7 +809,7 @@ pub fn unnecessary_list_comprehension_set(
 pub fn unnecessary_list_comprehension_dict(
    expr: &Expr,
    func: &Expr,
-    args: &Vec<Expr>,
+    args: &[Expr],
 ) -> Option<Check> {
    if args.len() == 1 {
        if let ExprKind::Name { id, .. } = &func.node {
@@ -837,7 +832,7 @@ pub fn unnecessary_list_comprehension_dict(
 }

 /// Check `set([1, 2])` compliance.
-pub fn unnecessary_literal_set(expr: &Expr, func: &Expr, args: &Vec<Expr>) -> Option<Check> {
+pub fn unnecessary_literal_set(expr: &Expr, func: &Expr, args: &[Expr]) -> Option<Check> {
    if args.len() == 1 {
        if let ExprKind::Name { id, .. } = &func.node {
            if id == "set" {
@@ -863,7 +858,7 @@ pub fn unnecessary_literal_set(expr: &Expr, func: &Expr, args: &Vec<Expr>) -> Op
 }

 /// Check `dict([(1, 2)])` compliance.
-pub fn unnecessary_literal_dict(expr: &Expr, func: &Expr, args: &Vec<Expr>) -> Option<Check> {
+pub fn unnecessary_literal_dict(expr: &Expr, func: &Expr, args: &[Expr]) -> Option<Check> {
    if args.len() == 1 {
        if let ExprKind::Name { id, .. } = &func.node {
            if id == "dict" {
@@ -919,8 +914,8 @@ pub fn unnecessary_literal_dict(expr: &Expr, func: &Expr, args: &Vec<Expr>) -> O
 pub fn unnecessary_collection_call(
    expr: &Expr,
    func: &Expr,
-    args: &Vec<Expr>,
-    keywords: &Vec<Located<KeywordData>>,
+    args: &[Expr],
+    keywords: &[Located<KeywordData>],
 ) -> Option<Check> {
    if args.is_empty() {
        if let ExprKind::Name { id, .. } = &func.node {
@@ -1142,8 +1137,8 @@ pub fn unnecessary_subscript_reversal(expr: &Expr, func: &Expr, args: &[Expr]) -

 pub fn unnecessary_comprehension(
    expr: &Expr,
-    elt: &Located<ExprKind>,
-    generators: &Vec<Comprehension>,
+    elt: &Expr,
+    generators: &[Comprehension],
 ) -> Option<Check> {
    if generators.len() == 1 {
        let generator = &generators[0];
@@ -1175,6 +1170,64 @@ pub fn unnecessary_comprehension(
    None
 }

+pub fn unnecessary_map(expr: &Expr, func: &Expr, args: &[Expr]) -> Option<Check> {
+    if let ExprKind::Name { id, .. } = &func.node {
+        if id == "map" {
+            if args.len() == 2 {
+                if let ExprKind::Lambda { .. } = &args[0].node {
+                    return Some(Check::new(
+                        CheckKind::UnnecessaryMap("generator".to_string()),
+                        Range::from_located(expr),
+                    ));
+                }
+            }
+        } else if id == "list" || id == "set" {
+            if let Some(arg) = args.first() {
+                if let ExprKind::Call { func, args, .. } = &arg.node {
+                    if let ExprKind::Name { id: f, .. } = &func.node {
+                        if f == "map" {
+                            if let Some(arg) = args.first() {
+                                if let ExprKind::Lambda { .. } = &arg.node {
+                                    return Some(Check::new(
+                                        CheckKind::UnnecessaryMap(id.to_string()),
+                                        Range::from_located(expr),
+                                    ));
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        } else if id == "dict" {
+            if args.len() == 1 {
+                if let ExprKind::Call { func, args, .. } = &args[0].node {
+                    if let ExprKind::Name { id: f, .. } = &func.node {
+                        if f == "map" {
+                            if let Some(arg) = args.first() {
+                                if let ExprKind::Lambda { body, .. } = &arg.node {
+                                    match &body.node {
+                                        ExprKind::Tuple { elts, .. }
+                                        | ExprKind::List { elts, .. }
+                                            if elts.len() == 2 =>
+                                        {
+                                            return Some(Check::new(
+                                                CheckKind::UnnecessaryMap(id.to_string()),
+                                                Range::from_located(expr),
+                                            ))
+                                        }
+                                        _ => {}
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    None
+}
+
 // flake8-super
 /// Check that `super()` has no args
 pub fn super_args(
@@ -1182,7 +1235,7 @@ pub fn super_args(
    parents: &[&Stmt],
    expr: &Expr,
    func: &Expr,
-    args: &Vec<Expr>,
+    args: &[Expr],
 ) -> Option<Check> {
    if !helpers::is_super_call_with_arguments(func, args) {
        return None;
@@ -1197,7 +1250,7 @@ pub fn super_args(

    // For a `super` invocation to be unnecessary, the first argument needs to match the enclosing
    // class, and the second argument needs to match the first argument to the enclosing function.
-    if let [first_arg, second_arg] = args.as_slice() {
+    if let [first_arg, second_arg] = args {
        // Find the enclosing function definition (if any).
        if let Some(StmtKind::FunctionDef {
            args: parent_args, ..
@@ -1273,3 +1326,99 @@ pub fn print_call(

    None
 }
+
+// pep8-naming
+pub fn invalid_class_name(class_def: &Stmt, name: &str) -> Option<Check> {
+    let stripped = name.strip_prefix('_').unwrap_or(name);
+    if !stripped
+        .chars()
+        .next()
+        .map(|c| c.is_uppercase())
+        .unwrap_or(false)
+        || stripped.contains('_')
+    {
+        return Some(Check::new(
+            CheckKind::InvalidClassName(name.to_string()),
+            Range::from_located(class_def),
+        ));
+    }
+    None
+}
+
+pub fn invalid_function_name(func_def: &Stmt, name: &str) -> Option<Check> {
+    if name.chars().any(|c| c.is_uppercase()) {
+        return Some(Check::new(
+            CheckKind::InvalidFunctionName(name.to_string()),
+            Range::from_located(func_def),
+        ));
+    }
+    None
+}
+
+pub fn invalid_argument_name(location: Range, name: &str) -> Option<Check> {
+    if name.chars().any(|c| c.is_uppercase()) {
+        return Some(Check::new(
+            CheckKind::InvalidArgumentName(name.to_string()),
+            location,
+        ));
+    }
+    None
+}
+
+pub fn invalid_first_argument_name_for_class_method(
+    scope: &Scope,
+    decorator_list: &[Expr],
+    args: &Arguments,
+) -> Option<Check> {
+    if !matches!(scope.kind, ScopeKind::Class) {
+        return None;
+    }
+
+    if decorator_list.iter().any(|decorator| {
+        if let ExprKind::Name { id, .. } = &decorator.node {
+            id == "classmethod"
+        } else {
+            false
+        }
+    }) {
+        if let Some(arg) = args.args.first() {
+            if arg.node.arg != "cls" {
+                return Some(Check::new(
+                    CheckKind::InvalidFirstArgumentNameForClassMethod,
+                    Range::from_located(arg),
+                ));
+            }
+        }
+    }
+    None
+}
+
+pub fn invalid_first_argument_name_for_method(
+    scope: &Scope,
+    decorator_list: &[Expr],
+    args: &Arguments,
+) -> Option<Check> {
+    if !matches!(scope.kind, ScopeKind::Class) {
+        return None;
+    }
+
+    if decorator_list.iter().any(|decorator| {
+        if let ExprKind::Name { id, .. } = &decorator.node {
+            id == "classmethod" || id == "staticmethod"
+        } else {
+            false
+        }
+    }) {
+        return None;
+    }
+
+    if let Some(arg) = args.args.first() {
+        if arg.node.arg != "self" {
+            return Some(Check::new(
+                CheckKind::InvalidFirstArgumentNameForMethod,
+                Range::from_located(arg),
+            ));
+        }
+    }
+    None
+}
--- a/src/ast/helpers.rs
+++ b/src/ast/helpers.rs
@@ -123,7 +123,7 @@ pub fn extract_handler_names(handlers: &[Excepthandler]) -> Vec<String> {
 }

 /// Returns `true` if a call is an argumented `super` invocation.
-pub fn is_super_call_with_arguments(func: &Expr, args: &Vec<Expr>) -> bool {
+pub fn is_super_call_with_arguments(func: &Expr, args: &[Expr]) -> bool {
    // Check: is this a `super` call?
    if let ExprKind::Name { id, .. } = &func.node {
        id == "super" && !args.is_empty()
--- a/src/ast/operations.rs
+++ b/src/ast/operations.rs
@@ -121,7 +121,7 @@ pub fn is_unpacking_assignment(stmt: &Stmt) -> bool {
 /// Struct used to efficiently slice source code at (row, column) Locations.
 pub struct SourceCodeLocator<'a> {
    content: &'a str,
-    offsets: Vec<usize>,
+    offsets: Vec<Vec<usize>>,
    initialized: bool,
 }

@@ -137,26 +137,32 @@ impl<'a> SourceCodeLocator<'a> {
    fn init(&mut self) {
        if !self.initialized {
            let mut offset = 0;
-            for i in self.content.lines() {
-                self.offsets.push(offset);
-                offset += i.len();
-                offset += 1;
+            for line in self.content.lines() {
+                let mut newline = 0;
+                let mut line_offsets: Vec<usize> = vec![];
+                for (i, _char) in line.char_indices() {
+                    line_offsets.push(offset + i);
+                    newline = i + 1;
+                }
+                line_offsets.push(offset + newline);
+                self.offsets.push(line_offsets);
+                offset += newline + 1;
            }
-            self.offsets.push(offset);
+            self.offsets.push(vec![offset]);
            self.initialized = true;
        }
    }

    pub fn slice_source_code_at(&mut self, location: &Location) -> &'a str {
        self.init();
-        let offset = self.offsets[location.row() - 1] + location.column() - 1;
+        let offset = self.offsets[location.row() - 1][location.column() - 1];
        &self.content[offset..]
    }

    pub fn slice_source_code_range(&mut self, range: &Range) -> &'a str {
        self.init();
-        let start = self.offsets[range.location.row() - 1] + range.location.column() - 1;
-        let end = self.offsets[range.end_location.row() - 1] + range.end_location.column() - 1;
+        let start = self.offsets[range.location.row() - 1][range.location.column() - 1];
+        let end = self.offsets[range.end_location.row() - 1][range.end_location.column() - 1];
        &self.content[start..end]
    }

@@ -166,12 +172,10 @@ impl<'a> SourceCodeLocator<'a> {
        inner: &Range,
    ) -> (&'a str, &'a str, &'a str) {
        self.init();
-        let outer_start = self.offsets[outer.location.row() - 1] + outer.location.column() - 1;
-        let outer_end =
-            self.offsets[outer.end_location.row() - 1] + outer.end_location.column() - 1;
-        let inner_start = self.offsets[inner.location.row() - 1] + inner.location.column() - 1;
-        let inner_end =
-            self.offsets[inner.end_location.row() - 1] + inner.end_location.column() - 1;
+        let outer_start = self.offsets[outer.location.row() - 1][outer.location.column() - 1];
+        let outer_end = self.offsets[outer.end_location.row() - 1][outer.end_location.column() - 1];
+        let inner_start = self.offsets[inner.location.row() - 1][inner.location.column() - 1];
+        let inner_end = self.offsets[inner.end_location.row() - 1][inner.end_location.column() - 1];
        (
            &self.content[outer_start..inner_start],
            &self.content[inner_start..inner_end],
--- a/src/cache.rs
+++ b/src/cache.rs
@@ -1,3 +1,9 @@
+// cacache uses asyncd-std which has no wasm support, so currently no caching support on wasm
+#![cfg_attr(
+    target_family = "wasm",
+    allow(unused_imports, unused_variables, dead_code)
+)]
+
 use std::collections::hash_map::DefaultHasher;
 use std::fs::{create_dir_all, File, Metadata};
 use std::hash::{Hash, Hasher};
@@ -5,6 +11,7 @@ use std::io::Write;
 use std::path::Path;

 use anyhow::Result;
+#[cfg(not(target_family = "wasm"))]
 use cacache::Error::EntryNotFound;
 use filetime::FileTime;
 use log::error;
@@ -107,6 +114,7 @@ pub fn get(
        return None;
    };

+    #[cfg(not(target_family = "wasm"))] // cacache needs async-std which doesn't support wasm
    match cacache::read_sync(cache_dir(), cache_key(path, settings, autofix)) {
        Ok(encoded) => match bincode::deserialize::<CheckResult>(&encoded[..]) {
            Ok(CheckResult {
@@ -137,12 +145,14 @@ pub fn set(
        return;
    };

+    #[cfg(not(target_family = "wasm"))] // modification date not supported on wasm
    let check_result = CheckResultRef {
        metadata: &CacheMetadata {
            mtime: FileTime::from_last_modification_time(metadata).unix_seconds(),
        },
        messages,
    };
+    #[cfg(not(target_family = "wasm"))] // cacache needs async-std which doesn't support wasm
    if let Err(e) = cacache::write_sync(
        cache_dir(),
        cache_key(path, settings, autofix),
--- a/src/check_ast.rs
+++ b/src/check_ast.rs
@@ -3,7 +3,6 @@ use std::ops::Deref;
 use std::path::Path;

 use log::error;
-use rustpython_ast::Location;
 use rustpython_parser::ast::{
    Arg, Arguments, Constant, Excepthandler, ExcepthandlerKind, Expr, ExprContext, ExprKind,
    KeywordData, Operator, Stmt, StmtKind, Suite,
@@ -21,20 +20,18 @@ use crate::ast::visitor::{walk_excepthandler, Visitor};
 use crate::ast::{checkers, helpers, operations, visitor};
 use crate::autofix::{fixer, fixes};
 use crate::checks::{Check, CheckCode, CheckKind};
-use crate::docstrings::docstring_checks;
-use crate::docstrings::types::{Definition, DefinitionKind, Documentable};
-use crate::plugins;
+use crate::docstrings::definition::{Definition, DefinitionKind, Documentable};
 use crate::python::builtins::{BUILTINS, MAGIC_GLOBALS};
 use crate::python::future::ALL_FEATURE_NAMES;
 use crate::settings::{PythonVersion, Settings};
 use crate::visibility::{module_visibility, transition_scope, Modifier, Visibility, VisibleScope};
+use crate::{docstrings, plugins};

 pub const GLOBAL_SCOPE_INDEX: usize = 0;

 pub struct Checker<'a> {
    // Input data.
    pub(crate) path: &'a Path,
-    // TODO(charlie): Separate immutable from mutable state. (None of these should ever change.)
    pub(crate) locator: SourceCodeLocator<'a>,
    pub(crate) settings: &'a Settings,
    pub(crate) autofix: &'a fixer::Mode,
@@ -216,6 +213,32 @@ where
                    }
                }

+                if self.settings.enabled.contains(&CheckCode::N802) {
+                    if let Some(check) = checkers::invalid_function_name(stmt, name) {
+                        self.checks.push(check);
+                    }
+                }
+
+                if self.settings.enabled.contains(&CheckCode::N804) {
+                    if let Some(check) = checkers::invalid_first_argument_name_for_class_method(
+                        self.current_scope(),
+                        decorator_list,
+                        args,
+                    ) {
+                        self.checks.push(check);
+                    }
+                }
+
+                if self.settings.enabled.contains(&CheckCode::N805) {
+                    if let Some(check) = checkers::invalid_first_argument_name_for_method(
+                        self.current_scope(),
+                        decorator_list,
+                        args,
+                    ) {
+                        self.checks.push(check);
+                    }
+                }
+
                self.check_builtin_shadowing(name, Range::from_located(stmt), true);

                // Visit the decorators and arguments, but avoid the body, which will be deferred.
@@ -266,11 +289,7 @@ where
                );
            }
            StmtKind::Return { .. } => {
-                if self
-                    .settings
-                    .enabled
-                    .contains(CheckKind::ReturnOutsideFunction.code())
-                {
+                if self.settings.enabled.contains(&CheckCode::F706) {
                    if let Some(scope_index) = self.scope_stack.last().cloned() {
                        match self.scopes[scope_index].kind {
                            ScopeKind::Class | ScopeKind::Module => {
@@ -304,6 +323,12 @@ where
                    }
                }

+                if self.settings.enabled.contains(&CheckCode::N801) {
+                    if let Some(check) = checkers::invalid_class_name(stmt, name) {
+                        self.checks.push(check);
+                    }
+                }
+
                self.check_builtin_shadowing(
                    name,
                    self.locate_check(Range::from_located(stmt)),
@@ -322,17 +347,13 @@ where
                self.push_scope(Scope::new(ScopeKind::Class))
            }
            StmtKind::Import { names } => {
-                if self
-                    .settings
-                    .enabled
-                    .contains(CheckKind::ModuleImportNotAtTopOfFile.code())
-                    && self.seen_import_boundary
-                    && stmt.location.column() == 1
-                {
-                    self.checks.push(Check::new(
-                        CheckKind::ModuleImportNotAtTopOfFile,
-                        self.locate_check(Range::from_located(stmt)),
-                    ));
+                if self.seen_import_boundary && stmt.location.column() == 1 {
+                    if self.settings.enabled.contains(&CheckCode::E402) {
+                        self.checks.push(Check::new(
+                            CheckKind::ModuleImportNotAtTopOfFile,
+                            self.locate_check(Range::from_located(stmt)),
+                        ));
+                    }
                }

                for alias in names {
@@ -383,17 +404,13 @@ where
                module,
                level,
            } => {
-                if self
-                    .settings
-                    .enabled
-                    .contains(CheckKind::ModuleImportNotAtTopOfFile.code())
-                    && self.seen_import_boundary
-                    && stmt.location.column() == 1
-                {
-                    self.checks.push(Check::new(
-                        CheckKind::ModuleImportNotAtTopOfFile,
-                        self.locate_check(Range::from_located(stmt)),
-                    ));
+                if self.seen_import_boundary && stmt.location.column() == 1 {
+                    if self.settings.enabled.contains(&CheckCode::E402) {
+                        self.checks.push(Check::new(
+                            CheckKind::ModuleImportNotAtTopOfFile,
+                            self.locate_check(Range::from_located(stmt)),
+                        ));
+                    }
                }

                for alias in names {
@@ -572,7 +589,7 @@ where
        let prev_visibile_scope = self.visible_scope.clone();
        match &stmt.node {
            StmtKind::FunctionDef { body, .. } | StmtKind::AsyncFunctionDef { body, .. } => {
-                let definition = docstring_checks::extract(
+                let definition = docstrings::extraction::extract(
                    &self.visible_scope,
                    stmt,
                    body,
@@ -590,7 +607,7 @@ where
                ));
            }
            StmtKind::ClassDef { body, .. } => {
-                let definition = docstring_checks::extract(
+                let definition = docstrings::extraction::extract(
                    &self.visible_scope,
                    stmt,
                    body,
@@ -865,6 +882,12 @@ where
                    };
                }

+                if self.settings.enabled.contains(&CheckCode::C417) {
+                    if let Some(check) = checkers::unnecessary_map(expr, func, args) {
+                        self.checks.push(check);
+                    };
+                }
+
                // pyupgrade
                if self.settings.enabled.contains(&CheckCode::U002)
                    && self.settings.target_version >= PythonVersion::Py310
@@ -905,32 +928,27 @@ where
            }
            ExprKind::Yield { .. } | ExprKind::YieldFrom { .. } | ExprKind::Await { .. } => {
                let scope = self.current_scope();
-                if self
-                    .settings
-                    .enabled
-                    .contains(CheckKind::YieldOutsideFunction.code())
-                    && matches!(scope.kind, ScopeKind::Class | ScopeKind::Module)
-                {
-                    self.checks.push(Check::new(
-                        CheckKind::YieldOutsideFunction,
-                        self.locate_check(Range::from_located(expr)),
-                    ));
+                if self.settings.enabled.contains(&CheckCode::F704) {
+                    if matches!(scope.kind, ScopeKind::Class | ScopeKind::Module) {
+                        self.checks.push(Check::new(
+                            CheckKind::YieldOutsideFunction,
+                            self.locate_check(Range::from_located(expr)),
+                        ));
+                    }
                }
            }
            ExprKind::JoinedStr { values } => {
-                if self.in_f_string.is_none()
-                    && self
-                        .settings
-                        .enabled
-                        .contains(CheckKind::FStringMissingPlaceholders.code())
-                    && !values
-                        .iter()
-                        .any(|value| matches!(value.node, ExprKind::FormattedValue { .. }))
-                {
-                    self.checks.push(Check::new(
-                        CheckKind::FStringMissingPlaceholders,
-                        self.locate_check(Range::from_located(expr)),
-                    ));
+                if self.settings.enabled.contains(&CheckCode::F541) {
+                    if self.in_f_string.is_none()
+                        && !values
+                            .iter()
+                            .any(|value| matches!(value.node, ExprKind::FormattedValue { .. }))
+                    {
+                        self.checks.push(Check::new(
+                            CheckKind::FStringMissingPlaceholders,
+                            self.locate_check(Range::from_located(expr)),
+                        ));
+                    }
                }
                self.in_f_string = Some(Range::from_located(expr));
            }
@@ -1330,6 +1348,14 @@ where
            }
        }

+        if self.settings.enabled.contains(&CheckCode::N803) {
+            if let Some(check) =
+                checkers::invalid_argument_name(Range::from_located(arg), &arg.node.arg)
+            {
+                self.checks.push(check);
+            }
+        }
+
        self.check_builtin_arg_shadowing(&arg.node.arg, Range::from_located(arg));
    }
 }
@@ -1677,7 +1703,7 @@ impl<'a> Checker<'a> {
    where
        'b: 'a,
    {
-        let docstring = docstring_checks::docstring_from(python_ast);
+        let docstring = docstrings::extraction::docstring_from(python_ast);
        self.docstrings.push((
            Definition {
                kind: if self.path.ends_with("__init__.py") {
@@ -1705,29 +1731,6 @@ impl<'a> Checker<'a> {
        'b: 'a,
    {
        while let Some((range, expression)) = self.deferred_string_annotations.pop() {
-            // HACK(charlie): We need to modify `range` such that it represents the range of the
-            // expression _within_ the string annotation (as opposed to the range of the string
-            // annotation itself). RustPython seems to return an off-by-one start column for every
-            // string value, so we check for double quotes (which are really triple quotes).
-            let contents = self.locator.slice_source_code_at(&range.location);
-            let range = if contents.starts_with("\"\"") || contents.starts_with("\'\'") {
-                Range {
-                    location: Location::new(range.location.row(), range.location.column() + 2),
-                    end_location: Location::new(
-                        range.end_location.row(),
-                        range.end_location.column() - 2,
-                    ),
-                }
-            } else {
-                Range {
-                    location: Location::new(range.location.row(), range.location.column()),
-                    end_location: Location::new(
-                        range.end_location.row(),
-                        range.end_location.column() - 1,
-                    ),
-                }
-            };
-
            if let Ok(mut expr) = parser::parse_expression(expression, "<filename>") {
                relocate_expr(&mut expr, range);
                allocator.push(expr);
@@ -1940,60 +1943,66 @@ impl<'a> Checker<'a> {

    fn check_docstrings(&mut self) {
        while let Some((docstring, visibility)) = self.docstrings.pop() {
-            if !docstring_checks::not_empty(self, &docstring) {
+            if !docstrings::plugins::not_empty(self, &docstring) {
                continue;
            }
-            if !docstring_checks::not_missing(self, &docstring, &visibility) {
+            if !docstrings::plugins::not_missing(self, &docstring, &visibility) {
                continue;
            }
            if self.settings.enabled.contains(&CheckCode::D200) {
-                docstring_checks::one_liner(self, &docstring);
+                docstrings::plugins::one_liner(self, &docstring);
            }
            if self.settings.enabled.contains(&CheckCode::D201)
                || self.settings.enabled.contains(&CheckCode::D202)
            {
-                docstring_checks::blank_before_after_function(self, &docstring);
+                docstrings::plugins::blank_before_after_function(self, &docstring);
            }
            if self.settings.enabled.contains(&CheckCode::D203)
                || self.settings.enabled.contains(&CheckCode::D204)
                || self.settings.enabled.contains(&CheckCode::D211)
            {
-                docstring_checks::blank_before_after_class(self, &docstring);
+                docstrings::plugins::blank_before_after_class(self, &docstring);
            }
            if self.settings.enabled.contains(&CheckCode::D205) {
-                docstring_checks::blank_after_summary(self, &docstring);
+                docstrings::plugins::blank_after_summary(self, &docstring);
+            }
+            if self.settings.enabled.contains(&CheckCode::D206)
+                || self.settings.enabled.contains(&CheckCode::D207)
+                || self.settings.enabled.contains(&CheckCode::D208)
+            {
+                docstrings::plugins::indent(self, &docstring);
            }
            if self.settings.enabled.contains(&CheckCode::D209) {
-                docstring_checks::newline_after_last_paragraph(self, &docstring);
+                docstrings::plugins::newline_after_last_paragraph(self, &docstring);
            }
            if self.settings.enabled.contains(&CheckCode::D210) {
-                docstring_checks::no_surrounding_whitespace(self, &docstring);
+                docstrings::plugins::no_surrounding_whitespace(self, &docstring);
            }
            if self.settings.enabled.contains(&CheckCode::D212)
                || self.settings.enabled.contains(&CheckCode::D213)
            {
-                docstring_checks::multi_line_summary_start(self, &docstring);
+                docstrings::plugins::multi_line_summary_start(self, &docstring);
            }
            if self.settings.enabled.contains(&CheckCode::D300) {
-                docstring_checks::triple_quotes(self, &docstring);
+                docstrings::plugins::triple_quotes(self, &docstring);
            }
            if self.settings.enabled.contains(&CheckCode::D400) {
-                docstring_checks::ends_with_period(self, &docstring);
+                docstrings::plugins::ends_with_period(self, &docstring);
            }
            if self.settings.enabled.contains(&CheckCode::D402) {
-                docstring_checks::no_signature(self, &docstring);
+                docstrings::plugins::no_signature(self, &docstring);
            }
            if self.settings.enabled.contains(&CheckCode::D403) {
-                docstring_checks::capitalized(self, &docstring);
+                docstrings::plugins::capitalized(self, &docstring);
            }
            if self.settings.enabled.contains(&CheckCode::D404) {
-                docstring_checks::starts_with_this(self, &docstring);
+                docstrings::plugins::starts_with_this(self, &docstring);
            }
            if self.settings.enabled.contains(&CheckCode::D415) {
-                docstring_checks::ends_with_punctuation(self, &docstring);
+                docstrings::plugins::ends_with_punctuation(self, &docstring);
            }
            if self.settings.enabled.contains(&CheckCode::D418) {
-                docstring_checks::if_needed(self, &docstring);
+                docstrings::plugins::if_needed(self, &docstring);
            }
            if self.settings.enabled.contains(&CheckCode::D212)
                || self.settings.enabled.contains(&CheckCode::D214)
@@ -2001,7 +2010,6 @@ impl<'a> Checker<'a> {
                || self.settings.enabled.contains(&CheckCode::D405)
                || self.settings.enabled.contains(&CheckCode::D406)
                || self.settings.enabled.contains(&CheckCode::D407)
-                || self.settings.enabled.contains(&CheckCode::D407)
                || self.settings.enabled.contains(&CheckCode::D408)
                || self.settings.enabled.contains(&CheckCode::D409)
                || self.settings.enabled.contains(&CheckCode::D410)
@@ -2009,20 +2017,17 @@ impl<'a> Checker<'a> {
                || self.settings.enabled.contains(&CheckCode::D412)
                || self.settings.enabled.contains(&CheckCode::D413)
                || self.settings.enabled.contains(&CheckCode::D414)
-                || self.settings.enabled.contains(&CheckCode::D414)
-                || self.settings.enabled.contains(&CheckCode::D414)
+                || self.settings.enabled.contains(&CheckCode::D416)
                || self.settings.enabled.contains(&CheckCode::D417)
            {
-                docstring_checks::check_sections(self, &docstring);
+                docstrings::plugins::sections(self, &docstring);
            }
        }
    }

    fn check_builtin_shadowing(&mut self, name: &str, location: Range, is_attribute: bool) {
-        let scope = self.current_scope();
-
        // flake8-builtins
-        if is_attribute && matches!(scope.kind, ScopeKind::Class) {
+        if is_attribute && matches!(self.current_scope().kind, ScopeKind::Class) {
            if self.settings.enabled.contains(&CheckCode::A003) {
                if let Some(check) = checkers::builtin_shadowing(
                    name,
@@ -2044,6 +2049,7 @@ impl<'a> Checker<'a> {
    }

    fn check_builtin_arg_shadowing(&mut self, name: &str, location: Range) {
+        // flake8-builtins
        if self.settings.enabled.contains(&CheckCode::A002) {
            if let Some(check) = checkers::builtin_shadowing(
                name,
--- a/src/checks.rs
+++ b/src/checks.rs
@@ -8,55 +8,6 @@ use strum_macros::{AsRefStr, EnumIter, EnumString};
 use crate::ast::checkers::Primitive;
 use crate::ast::types::Range;

-pub const DEFAULT_CHECK_CODES: [CheckCode; 43] = [
-    // pycodestyle errors
-    CheckCode::E402,
-    CheckCode::E501,
-    CheckCode::E711,
-    CheckCode::E712,
-    CheckCode::E713,
-    CheckCode::E714,
-    CheckCode::E721,
-    CheckCode::E722,
-    CheckCode::E731,
-    CheckCode::E741,
-    CheckCode::E742,
-    CheckCode::E743,
-    CheckCode::E902,
-    CheckCode::E999,
-    // pycodestyle warnings
-    CheckCode::W292,
-    // pyflakes
-    CheckCode::F401,
-    CheckCode::F402,
-    CheckCode::F403,
-    CheckCode::F404,
-    CheckCode::F405,
-    CheckCode::F406,
-    CheckCode::F407,
-    CheckCode::F541,
-    CheckCode::F601,
-    CheckCode::F602,
-    CheckCode::F621,
-    CheckCode::F622,
-    CheckCode::F631,
-    CheckCode::F632,
-    CheckCode::F633,
-    CheckCode::F634,
-    CheckCode::F701,
-    CheckCode::F702,
-    CheckCode::F704,
-    CheckCode::F706,
-    CheckCode::F707,
-    CheckCode::F722,
-    CheckCode::F821,
-    CheckCode::F822,
-    CheckCode::F823,
-    CheckCode::F831,
-    CheckCode::F841,
-    CheckCode::F901,
-];
-
 #[derive(
    AsRefStr,
    EnumIter,
@@ -142,6 +93,7 @@ pub enum CheckCode {
    C414,
    C415,
    C416,
+    C417,
    // flake8-print
    T201,
    T203,
@@ -169,6 +121,9 @@ pub enum CheckCode {
    D203,
    D204,
    D205,
+    D206,
+    D207,
+    D208,
    D209,
    D210,
    D211,
@@ -192,13 +147,51 @@ pub enum CheckCode {
    D413,
    D414,
    D415,
+    D416,
    D417,
    D418,
    D419,
+    // pep8-naming
+    N801,
+    N802,
+    N803,
+    N804,
+    N805,
    // Meta
    M001,
 }

+#[derive(EnumIter, Debug, PartialEq, Eq)]
+pub enum CheckCategory {
+    Pyflakes,
+    Pycodestyle,
+    Pydocstyle,
+    Pyupgrade,
+    PEP8Naming,
+    Flake8Comprehensions,
+    Flake8Bugbear,
+    Flake8Builtins,
+    Flake8Print,
+    Meta,
+}
+
+impl CheckCategory {
+    pub fn title(&self) -> &'static str {
+        match self {
+            CheckCategory::Pycodestyle => "pycodestyle",
+            CheckCategory::Pyflakes => "Pyflakes",
+            CheckCategory::Flake8Builtins => "flake8-builtins",
+            CheckCategory::Flake8Bugbear => "flake8-bugbear",
+            CheckCategory::Flake8Comprehensions => "flake8-comprehensions",
+            CheckCategory::Flake8Print => "flake8-print",
+            CheckCategory::Pyupgrade => "pyupgrade",
+            CheckCategory::Pydocstyle => "pydocstyle",
+            CheckCategory::PEP8Naming => "pep8-naming",
+            CheckCategory::Meta => "Meta rules",
+        }
+    }
+}
+
 #[allow(clippy::upper_case_acronyms)]
 pub enum LintSource {
    AST,
@@ -283,6 +276,7 @@ pub enum CheckKind {
    UnnecessaryDoubleCastOrProcess(String, String),
    UnnecessarySubscriptReversal(String),
    UnnecessaryComprehension(String),
+    UnnecessaryMap(String),
    // flake8-print
    PrintFound,
    PPrintFound,
@@ -306,6 +300,7 @@ pub enum CheckKind {
    EndsInPunctuation,
    FirstLineCapitalized,
    FitsOnOneLine,
+    IndentWithSpaces,
    MagicMethod,
    MultiLineSummaryFirstLine,
    MultiLineSummarySecondLine,
@@ -316,9 +311,11 @@ pub enum CheckKind {
    NoBlankLineBeforeClass(usize),
    NoBlankLineBeforeFunction(usize),
    NoBlankLinesBetweenHeaderAndContent(String),
+    NoOverIndentation,
    NoSignature,
    NoSurroundingWhitespace,
    NoThisPrefix,
+    NoUnderIndentation,
    NonEmpty,
    NonEmptySection(String),
    OneBlankLineAfterClass(usize),
@@ -330,12 +327,19 @@ pub enum CheckKind {
    PublicModule,
    PublicNestedClass,
    PublicPackage,
+    SectionNameEndsInColon(String),
    SectionNotOverIndented(String),
    SectionUnderlineAfterName(String),
    SectionUnderlineMatchesSectionLength(String),
    SectionUnderlineNotOverIndented(String),
    SkipDocstring,
    UsesTripleQuotes,
+    // pep8-naming
+    InvalidClassName(String),
+    InvalidFunctionName(String),
+    InvalidArgumentName(String),
+    InvalidFirstArgumentNameForClassMethod,
+    InvalidFirstArgumentNameForMethod,
    // Meta
    UnusedNOQA(Option<Vec<String>>),
 }
@@ -344,7 +348,7 @@ impl CheckCode {
    /// The source for the check (either the AST, the filesystem, or the physical lines).
    pub fn lint_source(&self) -> &'static LintSource {
        match self {
-            CheckCode::E501 | CheckCode::M001 => &LintSource::Lines,
+            CheckCode::E501 | CheckCode::W292 | CheckCode::M001 => &LintSource::Lines,
            CheckCode::E902 => &LintSource::FileSystem,
            _ => &LintSource::AST,
        }
@@ -415,29 +419,30 @@ impl CheckCode {
            CheckCode::C402 => CheckKind::UnnecessaryGeneratorDict,
            CheckCode::C403 => CheckKind::UnnecessaryListComprehensionSet,
            CheckCode::C404 => CheckKind::UnnecessaryListComprehensionDict,
-            CheckCode::C405 => CheckKind::UnnecessaryLiteralSet("<list/tuple>".to_string()),
-            CheckCode::C406 => CheckKind::UnnecessaryLiteralDict("<list/tuple>".to_string()),
+            CheckCode::C405 => CheckKind::UnnecessaryLiteralSet("(list|tuple)".to_string()),
+            CheckCode::C406 => CheckKind::UnnecessaryLiteralDict("(list|tuple)".to_string()),
            CheckCode::C408 => {
-                CheckKind::UnnecessaryCollectionCall("<dict/list/tuple>".to_string())
+                CheckKind::UnnecessaryCollectionCall("(dict|list|tuple)".to_string())
            }
            CheckCode::C409 => {
-                CheckKind::UnnecessaryLiteralWithinTupleCall("<list/tuple>".to_string())
+                CheckKind::UnnecessaryLiteralWithinTupleCall("(list|tuple)".to_string())
            }
            CheckCode::C410 => {
-                CheckKind::UnnecessaryLiteralWithinListCall("<list/tuple>".to_string())
+                CheckKind::UnnecessaryLiteralWithinListCall("(list|tuple)".to_string())
            }
            CheckCode::C411 => CheckKind::UnnecessaryListCall,
            CheckCode::C413 => {
-                CheckKind::UnnecessaryCallAroundSorted("<list/reversed>".to_string())
+                CheckKind::UnnecessaryCallAroundSorted("(list|reversed)".to_string())
            }
            CheckCode::C414 => CheckKind::UnnecessaryDoubleCastOrProcess(
-                "<list/reversed/set/sorted/tuple>".to_string(),
-                "<list/set/sorted/tuple>".to_string(),
+                "(list|reversed|set|sorted|tuple)".to_string(),
+                "(list|set|sorted|tuple)".to_string(),
            ),
            CheckCode::C415 => {
-                CheckKind::UnnecessarySubscriptReversal("<reversed/set/sorted>".to_string())
+                CheckKind::UnnecessarySubscriptReversal("(reversed|set|sorted)".to_string())
            }
-            CheckCode::C416 => CheckKind::UnnecessaryComprehension("<list/set>".to_string()),
+            CheckCode::C416 => CheckKind::UnnecessaryComprehension("(list|set)".to_string()),
+            CheckCode::C417 => CheckKind::UnnecessaryMap("(list|set|dict)".to_string()),
            // flake8-print
            CheckCode::T201 => CheckKind::PrintFound,
            CheckCode::T203 => CheckKind::PPrintFound,
@@ -468,11 +473,16 @@ impl CheckCode {
            CheckCode::D203 => CheckKind::OneBlankLineBeforeClass(0),
            CheckCode::D204 => CheckKind::OneBlankLineAfterClass(0),
            CheckCode::D205 => CheckKind::NoBlankLineAfterSummary,
+            CheckCode::D206 => CheckKind::IndentWithSpaces,
+            CheckCode::D207 => CheckKind::NoUnderIndentation,
+            CheckCode::D208 => CheckKind::NoOverIndentation,
            CheckCode::D209 => CheckKind::NewLineAfterLastParagraph,
            CheckCode::D210 => CheckKind::NoSurroundingWhitespace,
            CheckCode::D211 => CheckKind::NoBlankLineBeforeClass(1),
            CheckCode::D212 => CheckKind::MultiLineSummaryFirstLine,
            CheckCode::D213 => CheckKind::MultiLineSummarySecondLine,
+            CheckCode::D214 => CheckKind::SectionNotOverIndented("Returns".to_string()),
+            CheckCode::D215 => CheckKind::SectionUnderlineNotOverIndented("Returns".to_string()),
            CheckCode::D300 => CheckKind::UsesTripleQuotes,
            CheckCode::D400 => CheckKind::EndsInPeriod,
            CheckCode::D402 => CheckKind::NoSignature,
@@ -493,17 +503,152 @@ impl CheckCode {
            CheckCode::D413 => CheckKind::BlankLineAfterLastSection("Returns".to_string()),
            CheckCode::D414 => CheckKind::NonEmptySection("Returns".to_string()),
            CheckCode::D415 => CheckKind::EndsInPunctuation,
-            CheckCode::D418 => CheckKind::SkipDocstring,
-            CheckCode::D419 => CheckKind::NonEmpty,
-            CheckCode::D214 => CheckKind::SectionNotOverIndented("Returns".to_string()),
-            CheckCode::D215 => CheckKind::SectionUnderlineNotOverIndented("Returns".to_string()),
+            CheckCode::D416 => CheckKind::SectionNameEndsInColon("Returns".to_string()),
            CheckCode::D417 => {
                CheckKind::DocumentAllArguments(vec!["x".to_string(), "y".to_string()])
            }
+            CheckCode::D418 => CheckKind::SkipDocstring,
+            CheckCode::D419 => CheckKind::NonEmpty,
+            // pep8-naming
+            CheckCode::N801 => CheckKind::InvalidClassName("...".to_string()),
+            CheckCode::N802 => CheckKind::InvalidFunctionName("...".to_string()),
+            CheckCode::N803 => CheckKind::InvalidArgumentName("...".to_string()),
+            CheckCode::N804 => CheckKind::InvalidFirstArgumentNameForClassMethod,
+            CheckCode::N805 => CheckKind::InvalidFirstArgumentNameForMethod,
            // Meta
            CheckCode::M001 => CheckKind::UnusedNOQA(None),
        }
    }
+
+    pub fn category(&self) -> CheckCategory {
+        match self {
+            CheckCode::E402 => CheckCategory::Pycodestyle,
+            CheckCode::E501 => CheckCategory::Pycodestyle,
+            CheckCode::E711 => CheckCategory::Pycodestyle,
+            CheckCode::E712 => CheckCategory::Pycodestyle,
+            CheckCode::E713 => CheckCategory::Pycodestyle,
+            CheckCode::E714 => CheckCategory::Pycodestyle,
+            CheckCode::E721 => CheckCategory::Pycodestyle,
+            CheckCode::E722 => CheckCategory::Pycodestyle,
+            CheckCode::E731 => CheckCategory::Pycodestyle,
+            CheckCode::E741 => CheckCategory::Pycodestyle,
+            CheckCode::E742 => CheckCategory::Pycodestyle,
+            CheckCode::E743 => CheckCategory::Pycodestyle,
+            CheckCode::E902 => CheckCategory::Pycodestyle,
+            CheckCode::E999 => CheckCategory::Pycodestyle,
+            CheckCode::W292 => CheckCategory::Pycodestyle,
+            CheckCode::F401 => CheckCategory::Pyflakes,
+            CheckCode::F402 => CheckCategory::Pyflakes,
+            CheckCode::F403 => CheckCategory::Pyflakes,
+            CheckCode::F404 => CheckCategory::Pyflakes,
+            CheckCode::F405 => CheckCategory::Pyflakes,
+            CheckCode::F406 => CheckCategory::Pyflakes,
+            CheckCode::F407 => CheckCategory::Pyflakes,
+            CheckCode::F541 => CheckCategory::Pyflakes,
+            CheckCode::F601 => CheckCategory::Pyflakes,
+            CheckCode::F602 => CheckCategory::Pyflakes,
+            CheckCode::F621 => CheckCategory::Pyflakes,
+            CheckCode::F622 => CheckCategory::Pyflakes,
+            CheckCode::F631 => CheckCategory::Pyflakes,
+            CheckCode::F632 => CheckCategory::Pyflakes,
+            CheckCode::F633 => CheckCategory::Pyflakes,
+            CheckCode::F634 => CheckCategory::Pyflakes,
+            CheckCode::F701 => CheckCategory::Pyflakes,
+            CheckCode::F702 => CheckCategory::Pyflakes,
+            CheckCode::F704 => CheckCategory::Pyflakes,
+            CheckCode::F706 => CheckCategory::Pyflakes,
+            CheckCode::F707 => CheckCategory::Pyflakes,
+            CheckCode::F722 => CheckCategory::Pyflakes,
+            CheckCode::F821 => CheckCategory::Pyflakes,
+            CheckCode::F822 => CheckCategory::Pyflakes,
+            CheckCode::F823 => CheckCategory::Pyflakes,
+            CheckCode::F831 => CheckCategory::Pyflakes,
+            CheckCode::F841 => CheckCategory::Pyflakes,
+            CheckCode::F901 => CheckCategory::Pyflakes,
+            CheckCode::A001 => CheckCategory::Flake8Builtins,
+            CheckCode::A002 => CheckCategory::Flake8Builtins,
+            CheckCode::A003 => CheckCategory::Flake8Builtins,
+            CheckCode::B011 => CheckCategory::Flake8Bugbear,
+            CheckCode::B014 => CheckCategory::Flake8Bugbear,
+            CheckCode::B025 => CheckCategory::Flake8Bugbear,
+            CheckCode::C400 => CheckCategory::Flake8Comprehensions,
+            CheckCode::C401 => CheckCategory::Flake8Comprehensions,
+            CheckCode::C402 => CheckCategory::Flake8Comprehensions,
+            CheckCode::C403 => CheckCategory::Flake8Comprehensions,
+            CheckCode::C404 => CheckCategory::Flake8Comprehensions,
+            CheckCode::C405 => CheckCategory::Flake8Comprehensions,
+            CheckCode::C406 => CheckCategory::Flake8Comprehensions,
+            CheckCode::C408 => CheckCategory::Flake8Comprehensions,
+            CheckCode::C409 => CheckCategory::Flake8Comprehensions,
+            CheckCode::C410 => CheckCategory::Flake8Comprehensions,
+            CheckCode::C411 => CheckCategory::Flake8Comprehensions,
+            CheckCode::C413 => CheckCategory::Flake8Comprehensions,
+            CheckCode::C414 => CheckCategory::Flake8Comprehensions,
+            CheckCode::C415 => CheckCategory::Flake8Comprehensions,
+            CheckCode::C416 => CheckCategory::Flake8Comprehensions,
+            CheckCode::C417 => CheckCategory::Flake8Comprehensions,
+            CheckCode::T201 => CheckCategory::Flake8Print,
+            CheckCode::T203 => CheckCategory::Flake8Print,
+            CheckCode::U001 => CheckCategory::Pyupgrade,
+            CheckCode::U002 => CheckCategory::Pyupgrade,
+            CheckCode::U003 => CheckCategory::Pyupgrade,
+            CheckCode::U004 => CheckCategory::Pyupgrade,
+            CheckCode::U005 => CheckCategory::Pyupgrade,
+            CheckCode::U006 => CheckCategory::Pyupgrade,
+            CheckCode::U007 => CheckCategory::Pyupgrade,
+            CheckCode::U008 => CheckCategory::Pyupgrade,
+            CheckCode::D100 => CheckCategory::Pydocstyle,
+            CheckCode::D101 => CheckCategory::Pydocstyle,
+            CheckCode::D102 => CheckCategory::Pydocstyle,
+            CheckCode::D103 => CheckCategory::Pydocstyle,
+            CheckCode::D104 => CheckCategory::Pydocstyle,
+            CheckCode::D105 => CheckCategory::Pydocstyle,
+            CheckCode::D106 => CheckCategory::Pydocstyle,
+            CheckCode::D107 => CheckCategory::Pydocstyle,
+            CheckCode::D200 => CheckCategory::Pydocstyle,
+            CheckCode::D201 => CheckCategory::Pydocstyle,
+            CheckCode::D202 => CheckCategory::Pydocstyle,
+            CheckCode::D203 => CheckCategory::Pydocstyle,
+            CheckCode::D204 => CheckCategory::Pydocstyle,
+            CheckCode::D205 => CheckCategory::Pydocstyle,
+            CheckCode::D206 => CheckCategory::Pydocstyle,
+            CheckCode::D207 => CheckCategory::Pydocstyle,
+            CheckCode::D208 => CheckCategory::Pydocstyle,
+            CheckCode::D209 => CheckCategory::Pydocstyle,
+            CheckCode::D210 => CheckCategory::Pydocstyle,
+            CheckCode::D211 => CheckCategory::Pydocstyle,
+            CheckCode::D212 => CheckCategory::Pydocstyle,
+            CheckCode::D213 => CheckCategory::Pydocstyle,
+            CheckCode::D214 => CheckCategory::Pydocstyle,
+            CheckCode::D215 => CheckCategory::Pydocstyle,
+            CheckCode::D300 => CheckCategory::Pydocstyle,
+            CheckCode::D400 => CheckCategory::Pydocstyle,
+            CheckCode::D402 => CheckCategory::Pydocstyle,
+            CheckCode::D403 => CheckCategory::Pydocstyle,
+            CheckCode::D404 => CheckCategory::Pydocstyle,
+            CheckCode::D405 => CheckCategory::Pydocstyle,
+            CheckCode::D406 => CheckCategory::Pydocstyle,
+            CheckCode::D407 => CheckCategory::Pydocstyle,
+            CheckCode::D408 => CheckCategory::Pydocstyle,
+            CheckCode::D409 => CheckCategory::Pydocstyle,
+            CheckCode::D410 => CheckCategory::Pydocstyle,
+            CheckCode::D411 => CheckCategory::Pydocstyle,
+            CheckCode::D412 => CheckCategory::Pydocstyle,
+            CheckCode::D413 => CheckCategory::Pydocstyle,
+            CheckCode::D414 => CheckCategory::Pydocstyle,
+            CheckCode::D415 => CheckCategory::Pydocstyle,
+            CheckCode::D416 => CheckCategory::Pydocstyle,
+            CheckCode::D417 => CheckCategory::Pydocstyle,
+            CheckCode::D418 => CheckCategory::Pydocstyle,
+            CheckCode::D419 => CheckCategory::Pydocstyle,
+            CheckCode::N801 => CheckCategory::PEP8Naming,
+            CheckCode::N802 => CheckCategory::PEP8Naming,
+            CheckCode::N803 => CheckCategory::PEP8Naming,
+            CheckCode::N804 => CheckCategory::PEP8Naming,
+            CheckCode::N805 => CheckCategory::PEP8Naming,
+            CheckCode::M001 => CheckCategory::Meta,
+        }
+    }
 }

 impl CheckKind {
@@ -579,6 +724,7 @@ impl CheckKind {
            CheckKind::UnnecessaryDoubleCastOrProcess(..) => &CheckCode::C414,
            CheckKind::UnnecessarySubscriptReversal(_) => &CheckCode::C415,
            CheckKind::UnnecessaryComprehension(..) => &CheckCode::C416,
+            CheckKind::UnnecessaryMap(_) => &CheckCode::C417,
            // flake8-print
            CheckKind::PrintFound => &CheckCode::T201,
            CheckKind::PPrintFound => &CheckCode::T203,
@@ -602,6 +748,7 @@ impl CheckKind {
            CheckKind::EndsInPunctuation => &CheckCode::D415,
            CheckKind::FirstLineCapitalized => &CheckCode::D403,
            CheckKind::FitsOnOneLine => &CheckCode::D200,
+            CheckKind::IndentWithSpaces => &CheckCode::D206,
            CheckKind::MagicMethod => &CheckCode::D105,
            CheckKind::MultiLineSummaryFirstLine => &CheckCode::D212,
            CheckKind::MultiLineSummarySecondLine => &CheckCode::D213,
@@ -612,9 +759,11 @@ impl CheckKind {
            CheckKind::NoBlankLineBeforeClass(_) => &CheckCode::D211,
            CheckKind::NoBlankLineBeforeFunction(_) => &CheckCode::D201,
            CheckKind::NoBlankLinesBetweenHeaderAndContent(_) => &CheckCode::D412,
+            CheckKind::NoOverIndentation => &CheckCode::D208,
            CheckKind::NoSignature => &CheckCode::D402,
            CheckKind::NoSurroundingWhitespace => &CheckCode::D210,
            CheckKind::NoThisPrefix => &CheckCode::D404,
+            CheckKind::NoUnderIndentation => &CheckCode::D207,
            CheckKind::NonEmpty => &CheckCode::D419,
            CheckKind::NonEmptySection(_) => &CheckCode::D414,
            CheckKind::OneBlankLineAfterClass(_) => &CheckCode::D204,
@@ -626,12 +775,19 @@ impl CheckKind {
            CheckKind::PublicModule => &CheckCode::D100,
            CheckKind::PublicNestedClass => &CheckCode::D106,
            CheckKind::PublicPackage => &CheckCode::D104,
+            CheckKind::SectionNameEndsInColon(_) => &CheckCode::D416,
            CheckKind::SectionNotOverIndented(_) => &CheckCode::D214,
            CheckKind::SectionUnderlineAfterName(_) => &CheckCode::D408,
            CheckKind::SectionUnderlineMatchesSectionLength(_) => &CheckCode::D409,
            CheckKind::SectionUnderlineNotOverIndented(_) => &CheckCode::D215,
            CheckKind::SkipDocstring => &CheckCode::D418,
            CheckKind::UsesTripleQuotes => &CheckCode::D300,
+            // pep8-naming
+            CheckKind::InvalidClassName(_) => &CheckCode::N801,
+            CheckKind::InvalidFunctionName(_) => &CheckCode::N802,
+            CheckKind::InvalidArgumentName(_) => &CheckCode::N803,
+            CheckKind::InvalidFirstArgumentNameForClassMethod => &CheckCode::N804,
+            CheckKind::InvalidFirstArgumentNameForMethod => &CheckCode::N805,
            // Meta
            CheckKind::UnusedNOQA(_) => &CheckCode::M001,
        }
@@ -799,65 +955,72 @@ impl CheckKind {
            }
            // flake8-comprehensions
            CheckKind::UnnecessaryGeneratorList => {
-                "Unnecessary generator - rewrite as a list comprehension".to_string()
+                "Unnecessary generator (rewrite as a `list` comprehension)".to_string()
            }
            CheckKind::UnnecessaryGeneratorSet => {
-                "Unnecessary generator - rewrite as a set comprehension".to_string()
+                "Unnecessary generator (rewrite as a `set` comprehension)".to_string()
            }
            CheckKind::UnnecessaryGeneratorDict => {
-                "Unnecessary generator - rewrite as a dict comprehension".to_string()
+                "Unnecessary generator (rewrite as a `dict` comprehension)".to_string()
            }
            CheckKind::UnnecessaryListComprehensionSet => {
-                "Unnecessary list comprehension - rewrite as a set comprehension".to_string()
+                "Unnecessary `list` comprehension (rewrite as a `set` comprehension)".to_string()
            }
            CheckKind::UnnecessaryListComprehensionDict => {
-                "Unnecessary list comprehension - rewrite as a dict comprehension".to_string()
+                "Unnecessary `list` comprehension (rewrite as a `dict` comprehension)".to_string()
            }
            CheckKind::UnnecessaryLiteralSet(obj_type) => {
-                format!("Unnecessary {obj_type} literal - rewrite as a set literal")
+                format!("Unnecessary `{obj_type}` literal (rewrite as a `set` literal)")
            }
            CheckKind::UnnecessaryLiteralDict(obj_type) => {
-                format!("Unnecessary {obj_type} literal - rewrite as a dict literal")
+                format!("Unnecessary `{obj_type}` literal (rewrite as a `dict` literal)")
            }
            CheckKind::UnnecessaryCollectionCall(obj_type) => {
-                format!("Unnecessary {obj_type} call - rewrite as a literal")
+                format!("Unnecessary `{obj_type}` call (rewrite as a literal)")
            }
            CheckKind::UnnecessaryLiteralWithinTupleCall(literal) => {
                if literal == "list" {
                    format!(
-                        "Unnecessary {literal} literal passed to tuple() - rewrite as a tuple literal"
+                        "Unnecessary `{literal}` literal passed to `tuple()` (rewrite as a `tuple` literal)"
                    )
                } else {
                    format!(
-                        "Unnecessary {literal} literal passed to tuple() - remove the outer call to tuple()"
+                        "Unnecessary `{literal}` literal passed to `tuple()` (remove the outer call to `tuple()`)"
                    )
                }
            }
            CheckKind::UnnecessaryLiteralWithinListCall(literal) => {
                if literal == "list" {
                    format!(
-                        "Unnecessary {literal} literal passed to list() - remove the outer call to list()"
+                        "Unnecessary `{literal}` literal passed to `list()` (remove the outer call to `list()`)"
                    )
                } else {
                    format!(
-                        "Unnecessary {literal} literal passed to list() - rewrite as a list literal"
+                        "Unnecessary `{literal}` literal passed to `list()` (rewrite as a `list` literal)"
                    )
                }
            }
            CheckKind::UnnecessaryListCall => {
-                "Unnecessary list call - remove the outer call to list()".to_string()
+                "Unnecessary `list` call (remove the outer call to `list()`)".to_string()
            }
            CheckKind::UnnecessaryCallAroundSorted(func) => {
-                format!("Unnecessary {func} call around sorted()")
+                format!("Unnecessary `{func}` call around `sorted()`")
            }
            CheckKind::UnnecessaryDoubleCastOrProcess(inner, outer) => {
-                format!("Unnecessary {inner} call within {outer}().")
+                format!("Unnecessary `{inner}` call within `{outer}()`")
            }
            CheckKind::UnnecessarySubscriptReversal(func) => {
-                format!("Unnecessary subscript reversal of iterable within {func}()")
+                format!("Unnecessary subscript reversal of iterable within `{func}()`")
            }
            CheckKind::UnnecessaryComprehension(obj_type) => {
-                format!(" Unnecessary {obj_type} comprehension - rewrite using {obj_type}()")
+                format!(" Unnecessary `{obj_type}` comprehension (rewrite using `{obj_type}()`)")
+            }
+            CheckKind::UnnecessaryMap(obj_type) => {
+                if obj_type == "generator" {
+                    "Unnecessary `map` usage (rewrite using a generator expression)".to_string()
+                } else {
+                    format!("Unnecessary `map` usage (rewrite using a `{obj_type}` comprehension)")
+                }
            }
            // flake8-print
            CheckKind::PrintFound => "`print` found".to_string(),
@@ -939,7 +1102,7 @@ impl CheckKind {
            CheckKind::PublicPackage => "Missing docstring in public package".to_string(),
            CheckKind::MagicMethod => "Missing docstring in magic method".to_string(),
            CheckKind::PublicNestedClass => "Missing docstring in public nested class".to_string(),
-            CheckKind::PublicInit => "Missing docstring in __init__".to_string(),
+            CheckKind::PublicInit => "Missing docstring in `__init__`".to_string(),
            CheckKind::NoThisPrefix => {
                "First word of the docstring should not be `This`".to_string()
            }
@@ -982,6 +1145,9 @@ impl CheckKind {
            CheckKind::SectionUnderlineNotOverIndented(name) => {
                format!("Section underline is over-indented (\"{name}\")")
            }
+            CheckKind::SectionNameEndsInColon(name) => {
+                format!("Section name should end with a colon (\"{name}\")")
+            }
            CheckKind::DocumentAllArguments(names) => {
                if names.len() == 1 {
                    let name = &names[0];
@@ -991,6 +1157,27 @@ impl CheckKind {
                    format!("Missing argument descriptions in the docstring: {names}")
                }
            }
+            CheckKind::IndentWithSpaces => {
+                "Docstring should be indented with spaces, not tabs".to_string()
+            }
+            CheckKind::NoUnderIndentation => "Docstring is under-indented".to_string(),
+            CheckKind::NoOverIndentation => "Docstring is over-indented".to_string(),
+            // pep8-naming
+            CheckKind::InvalidClassName(name) => {
+                format!("Class name `{name}` should use CapWords convention ")
+            }
+            CheckKind::InvalidFunctionName(name) => {
+                format!("Function name `{name}` should be lowercase")
+            }
+            CheckKind::InvalidArgumentName(name) => {
+                format!("Argument name `{name}` should be lowercase")
+            }
+            CheckKind::InvalidFirstArgumentNameForClassMethod => {
+                "First argument of a class method should be named `cls`".to_string()
+            }
+            CheckKind::InvalidFirstArgumentNameForMethod => {
+                "First argument of a method should be named `self`".to_string()
+            }
            // Meta
            CheckKind::UnusedNOQA(codes) => match codes {
                None => "Unused `noqa` directive".to_string(),
@@ -1015,9 +1202,19 @@ impl CheckKind {
    pub fn fixable(&self) -> bool {
        matches!(
            self,
-            CheckKind::DeprecatedUnittestAlias(_, _)
+            CheckKind::BlankLineAfterLastSection(_)
+                | CheckKind::BlankLineAfterSection(_)
+                | CheckKind::DeprecatedUnittestAlias(_, _)
                | CheckKind::DoNotAssertFalse
                | CheckKind::DuplicateHandlerException(_)
+                | CheckKind::NewLineAfterLastParagraph
+                | CheckKind::NoBlankLineAfterFunction(_)
+                | CheckKind::NoBlankLineAfterSummary
+                | CheckKind::NoBlankLineBeforeClass(_)
+                | CheckKind::NoBlankLineBeforeFunction(_)
+                | CheckKind::NoSurroundingWhitespace
+                | CheckKind::OneBlankLineAfterClass(_)
+                | CheckKind::OneBlankLineBeforeClass(_)
                | CheckKind::PPrintFound
                | CheckKind::PrintFound
                | CheckKind::SuperCallWithParameters
@@ -1025,10 +1222,10 @@ impl CheckKind {
                | CheckKind::UnnecessaryAbspath
                | CheckKind::UnusedImport(_)
                | CheckKind::UnusedNOQA(_)
-                | CheckKind::UselessMetaclassType
-                | CheckKind::UselessObjectInheritance(_)
                | CheckKind::UsePEP585Annotation(_)
                | CheckKind::UsePEP604Annotation
+                | CheckKind::UselessMetaclassType
+                | CheckKind::UselessObjectInheritance(_)
        )
    }
 }
@@ -1041,6 +1238,35 @@ pub struct Fix {
    pub applied: bool,
 }

+impl Fix {
+    pub fn deletion(start: Location, end: Location) -> Self {
+        Self {
+            content: "".to_string(),
+            location: start,
+            end_location: end,
+            applied: false,
+        }
+    }
+
+    pub fn replacement(content: String, start: Location, end: Location) -> Self {
+        Self {
+            content,
+            location: start,
+            end_location: end,
+            applied: false,
+        }
+    }
+
+    pub fn insertion(content: String, at: Location) -> Self {
+        Self {
+            content,
+            location: at,
+            end_location: at,
+            applied: false,
+        }
+    }
+}
+
 #[derive(Debug, PartialEq, Eq, Serialize, Deserialize)]
 pub struct Check {
    pub kind: CheckKind,
@@ -1050,11 +1276,11 @@ pub struct Check {
 }

 impl Check {
-    pub fn new(kind: CheckKind, span: Range) -> Self {
+    pub fn new(kind: CheckKind, rage: Range) -> Self {
        Self {
            kind,
-            location: span.location,
-            end_location: span.end_location,
+            location: rage.location,
+            end_location: rage.end_location,
            fix: None,
        }
    }
--- a/src/cli.rs
+++ b/src/cli.rs
@@ -103,9 +103,9 @@ impl fmt::Display for Warnable {
 /// Warn the user if they attempt to enable a code that won't be respected.
 pub fn warn_on(
    flag: Warnable,
-    codes: &Vec<CheckCode>,
-    cli_ignore: &Vec<CheckCode>,
-    cli_extend_ignore: &Vec<CheckCode>,
+    codes: &[CheckCode],
+    cli_ignore: &[CheckCode],
+    cli_extend_ignore: &[CheckCode],
    pyproject_settings: &RawSettings,
    pyproject_path: &Option<PathBuf>,
 ) {
--- a/src/docstrings.rs
+++ b/src/docstrings.rs
@@ -1,3 +1,8 @@
-pub mod docstring_checks;
+pub mod definition;
+pub mod extraction;
+mod google;
+mod helpers;
+mod numpy;
+pub mod plugins;
 pub mod sections;
-pub mod types;
+mod styles;
--- a/src/docstrings/definition.rs
+++ b/src/docstrings/definition.rs
--- a/src/docstrings/extraction.rs
+++ b/src/docstrings/extraction.rs
@@ -0,0 +1,82 @@
+//! Extract docstrings from an AST.
+
+use rustpython_ast::{Constant, Expr, ExprKind, Stmt, StmtKind};
+
+use crate::docstrings::definition::{Definition, DefinitionKind, Documentable};
+use crate::visibility::{Modifier, VisibleScope};
+
+/// Extract a docstring from a function or class body.
+pub fn docstring_from(suite: &[Stmt]) -> Option<&Expr> {
+    if let Some(stmt) = suite.first() {
+        if let StmtKind::Expr { value } = &stmt.node {
+            if matches!(
+                &value.node,
+                ExprKind::Constant {
+                    value: Constant::Str(_),
+                    ..
+                }
+            ) {
+                return Some(value);
+            }
+        }
+    }
+    None
+}
+
+/// Extract a `Definition` from the AST node defined by a `Stmt`.
+pub fn extract<'a>(
+    scope: &VisibleScope,
+    stmt: &'a Stmt,
+    body: &'a [Stmt],
+    kind: &Documentable,
+) -> Definition<'a> {
+    let expr = docstring_from(body);
+    match kind {
+        Documentable::Function => match scope {
+            VisibleScope {
+                modifier: Modifier::Module,
+                ..
+            } => Definition {
+                kind: DefinitionKind::Function(stmt),
+                docstring: expr,
+            },
+            VisibleScope {
+                modifier: Modifier::Class,
+                ..
+            } => Definition {
+                kind: DefinitionKind::Method(stmt),
+                docstring: expr,
+            },
+            VisibleScope {
+                modifier: Modifier::Function,
+                ..
+            } => Definition {
+                kind: DefinitionKind::NestedFunction(stmt),
+                docstring: expr,
+            },
+        },
+        Documentable::Class => match scope {
+            VisibleScope {
+                modifier: Modifier::Module,
+                ..
+            } => Definition {
+                kind: DefinitionKind::Class(stmt),
+                docstring: expr,
+            },
+            VisibleScope {
+                modifier: Modifier::Class,
+                ..
+            } => Definition {
+                kind: DefinitionKind::NestedClass(stmt),
+                docstring: expr,
+            },
+            VisibleScope {
+                modifier: Modifier::Function,
+                ..
+            } => Definition {
+                kind: DefinitionKind::NestedClass(stmt),
+                docstring: expr,
+            },
+        },
+    }
+}
--- a/src/docstrings/google.rs
+++ b/src/docstrings/google.rs
@@ -0,0 +1,150 @@
+//! Abstractions for Google-style docstrings.
+
+use std::collections::BTreeSet;
+
+use crate::ast::types::Range;
+use once_cell::sync::Lazy;
+use regex::Regex;
+
+use crate::check_ast::Checker;
+use crate::checks::{Check, CheckCode, CheckKind};
+use crate::docstrings::definition::Definition;
+use crate::docstrings::sections;
+use crate::docstrings::sections::SectionContext;
+use crate::docstrings::styles::SectionStyle;
+
+pub(crate) static GOOGLE_SECTION_NAMES: Lazy<BTreeSet<&'static str>> = Lazy::new(|| {
+    BTreeSet::from([
+        "Args",
+        "Arguments",
+        "Attention",
+        "Attributes",
+        "Caution",
+        "Danger",
+        "Error",
+        "Example",
+        "Examples",
+        "Hint",
+        "Important",
+        "Keyword Args",
+        "Keyword Arguments",
+        "Methods",
+        "Note",
+        "Notes",
+        "Return",
+        "Returns",
+        "Raises",
+        "References",
+        "See Also",
+        "Tip",
+        "Todo",
+        "Warning",
+        "Warnings",
+        "Warns",
+        "Yield",
+        "Yields",
+    ])
+});
+
+pub(crate) static LOWERCASE_GOOGLE_SECTION_NAMES: Lazy<BTreeSet<&'static str>> = Lazy::new(|| {
+    BTreeSet::from([
+        "args",
+        "arguments",
+        "attention",
+        "attributes",
+        "caution",
+        "danger",
+        "error",
+        "example",
+        "examples",
+        "hint",
+        "important",
+        "keyword args",
+        "keyword arguments",
+        "methods",
+        "note",
+        "notes",
+        "return",
+        "returns",
+        "raises",
+        "references",
+        "see also",
+        "tip",
+        "todo",
+        "warning",
+        "warnings",
+        "warns",
+        "yield",
+        "yields",
+    ])
+});
+
+// See: `GOOGLE_ARGS_REGEX` in `pydocstyle/checker.py`.
+static GOOGLE_ARGS_REGEX: Lazy<Regex> =
+    Lazy::new(|| Regex::new(r"^\s*(\w+)\s*(\(.*?\))?\s*:\n?\s*.+").expect("Invalid regex"));
+
+fn check_args_section(checker: &mut Checker, definition: &Definition, context: &SectionContext) {
+    let mut args_sections: Vec<String> = vec![];
+    for line in textwrap::dedent(&context.following_lines.join("\n")).lines() {
+        if line
+            .chars()
+            .next()
+            .map(|char| char.is_whitespace())
+            .unwrap_or(true)
+        {
+            // This is a continuation of documentation for the last
+            // parameter because it does start with whitespace.
+            if let Some(current) = args_sections.last_mut() {
+                current.push_str(line);
+            }
+        } else {
+            // This line is the start of documentation for the next
+            // parameter because it doesn't start with any whitespace.
+            args_sections.push(line.to_string());
+        }
+    }
+
+    sections::check_missing_args(
+        checker,
+        definition,
+        // Collect the list of arguments documented in the docstring.
+        &BTreeSet::from_iter(args_sections.iter().filter_map(|section| {
+            match GOOGLE_ARGS_REGEX.captures(section.as_str()) {
+                Some(caps) => caps.get(1).map(|arg_name| arg_name.as_str()),
+                None => None,
+            }
+        })),
+    )
+}
+
+pub(crate) fn check_google_section(
+    checker: &mut Checker,
+    definition: &Definition,
+    context: &SectionContext,
+) {
+    sections::check_common_section(checker, definition, context, &SectionStyle::Google);
+
+    if checker.settings.enabled.contains(&CheckCode::D416) {
+        let suffix = context
+            .line
+            .trim()
+            .strip_prefix(&context.section_name)
+            .unwrap();
+        if suffix != ":" {
+            let docstring = definition
+                .docstring
+                .expect("Sections are only available for docstrings.");
+            checker.add_check(Check::new(
+                CheckKind::SectionNameEndsInColon(context.section_name.to_string()),
+                Range::from_located(docstring),
+            ))
+        }
+    }
+
+    if checker.settings.enabled.contains(&CheckCode::D417) {
+        let capitalized_section_name = titlecase::titlecase(&context.section_name);
+        if capitalized_section_name == "Args" || capitalized_section_name == "Arguments" {
+            check_args_section(checker, definition, context);
+        }
+    }
+}
--- a/src/docstrings/helpers.rs
+++ b/src/docstrings/helpers.rs
@@ -0,0 +1,34 @@
+use rustpython_ast::{Expr, Location};
+
+use crate::ast::types::Range;
+use crate::check_ast::Checker;
+
+pub const TRIPLE_QUOTE_PREFIXES: &[&str] = &[
+    "ur\"\"\"", "ur'''", "u\"\"\"", "u'''", "r\"\"\"", "r'''", "\"\"\"", "'''",
+];
+
+pub const SINGLE_QUOTE_PREFIXES: &[&str] = &["ur\"", "ur'", "u\"", "u'", "r\"", "r'", "\"", "'"];
+
+/// Extract the leading words from a line of text.
+pub fn leading_words(line: &str) -> String {
+    line.trim()
+        .chars()
+        .take_while(|char| char.is_alphanumeric() || char.is_whitespace())
+        .collect()
+}
+
+/// Extract the leading whitespace from a line of text.
+pub fn leading_space(line: &str) -> String {
+    line.chars()
+        .take_while(|char| char.is_whitespace())
+        .collect()
+}
+
+/// Extract the leading indentation from a docstring.
+pub fn indentation<'a>(checker: &'a mut Checker, docstring: &Expr) -> &'a str {
+    let range = Range::from_located(docstring);
+    checker.locator.slice_source_code_range(&Range {
+        location: Location::new(range.location.row(), 1),
+        end_location: Location::new(range.location.row(), range.location.column()),
+    })
+}
--- a/src/docstrings/numpy.rs
+++ b/src/docstrings/numpy.rs
@@ -0,0 +1,114 @@
+//! Abstractions for NumPy-style docstrings.
+
+use std::collections::BTreeSet;
+
+use crate::ast::types::Range;
+use once_cell::sync::Lazy;
+
+use crate::check_ast::Checker;
+use crate::checks::{Check, CheckCode, CheckKind};
+use crate::docstrings::definition::Definition;
+use crate::docstrings::sections::SectionContext;
+use crate::docstrings::styles::SectionStyle;
+use crate::docstrings::{helpers, sections};
+
+pub(crate) static LOWERCASE_NUMPY_SECTION_NAMES: Lazy<BTreeSet<&'static str>> = Lazy::new(|| {
+    BTreeSet::from([
+        "short summary",
+        "extended summary",
+        "parameters",
+        "returns",
+        "yields",
+        "other parameters",
+        "raises",
+        "see also",
+        "notes",
+        "references",
+        "examples",
+        "attributes",
+        "methods",
+    ])
+});
+
+pub(crate) static NUMPY_SECTION_NAMES: Lazy<BTreeSet<&'static str>> = Lazy::new(|| {
+    BTreeSet::from([
+        "Short Summary",
+        "Extended Summary",
+        "Parameters",
+        "Returns",
+        "Yields",
+        "Other Parameters",
+        "Raises",
+        "See Also",
+        "Notes",
+        "References",
+        "Examples",
+        "Attributes",
+        "Methods",
+    ])
+});
+
+fn check_parameters_section(
+    checker: &mut Checker,
+    definition: &Definition,
+    context: &SectionContext,
+) {
+    // Collect the list of arguments documented in the docstring.
+    let mut docstring_args: BTreeSet<&str> = Default::default();
+    let section_level_indent = helpers::leading_space(context.line);
+    for i in 1..context.following_lines.len() {
+        let current_line = context.following_lines[i - 1];
+        let current_leading_space = helpers::leading_space(current_line);
+        let next_line = context.following_lines[i];
+        if current_leading_space == section_level_indent
+            && (helpers::leading_space(next_line).len() > current_leading_space.len())
+            && !next_line.trim().is_empty()
+        {
+            let parameters = if let Some(semi_index) = current_line.find(':') {
+                // If the parameter has a type annotation, exclude it.
+                &current_line[..semi_index]
+            } else {
+                // Otherwise, it's just a list of parameters on the current line.
+                current_line.trim()
+            };
+            // Notably, NumPy lets you put multiple parameters of the same type on the same line.
+            for parameter in parameters.split(',') {
+                docstring_args.insert(parameter.trim());
+            }
+        }
+    }
+    // Validate that all arguments were documented.
+    sections::check_missing_args(checker, definition, &docstring_args);
+}
+
+pub(crate) fn check_numpy_section(
+    checker: &mut Checker,
+    definition: &Definition,
+    context: &SectionContext,
+) {
+    sections::check_common_section(checker, definition, context, &SectionStyle::NumPy);
+
+    if checker.settings.enabled.contains(&CheckCode::D406) {
+        let suffix = context
+            .line
+            .trim()
+            .strip_prefix(&context.section_name)
+            .unwrap();
+        if !suffix.is_empty() {
+            let docstring = definition
+                .docstring
+                .expect("Sections are only available for docstrings.");
+            checker.add_check(Check::new(
+                CheckKind::NewLineAfterSectionName(context.section_name.to_string()),
+                Range::from_located(docstring),
+            ))
+        }
+    }
+
+    if checker.settings.enabled.contains(&CheckCode::D417) {
+        let capitalized_section_name = titlecase::titlecase(&context.section_name);
+        if capitalized_section_name == "Parameters" {
+            check_parameters_section(checker, definition, context);
+        }
+    }
+}
--- a/src/docstrings/docstring_checks.rs
+++ b/src/docstrings/docstring_checks.rs
@@ -2,99 +2,21 @@

 use once_cell::sync::Lazy;
 use regex::Regex;
-use rustpython_ast::{Constant, Expr, ExprKind, Location, Stmt, StmtKind};
+use rustpython_ast::{Constant, ExprKind, Location, StmtKind};

 use crate::ast::types::Range;
+use crate::autofix::fixer;
 use crate::check_ast::Checker;
-use crate::checks::{Check, CheckCode, CheckKind};
-use crate::docstrings::sections::{check_numpy_section, section_contexts};
-use crate::docstrings::types::{Definition, DefinitionKind, Documentable};
-use crate::visibility::{is_init, is_magic, is_overload, Modifier, Visibility, VisibleScope};
-
-/// Extract a docstring from a function or class body.
-pub fn docstring_from(suite: &[Stmt]) -> Option<&Expr> {
-    if let Some(stmt) = suite.first() {
-        if let StmtKind::Expr { value } = &stmt.node {
-            if matches!(
-                &value.node,
-                ExprKind::Constant {
-                    value: Constant::Str(_),
-                    ..
-                }
-            ) {
-                return Some(value);
-            }
-        }
-    }
-    None
-}
-
-/// Extract a `Definition` from the AST node defined by a `Stmt`.
-pub fn extract<'a>(
-    scope: &VisibleScope,
-    stmt: &'a Stmt,
-    body: &'a [Stmt],
-    kind: &Documentable,
-) -> Definition<'a> {
-    let expr = docstring_from(body);
-    match kind {
-        Documentable::Function => match scope {
-            VisibleScope {
-                modifier: Modifier::Module,
-                ..
-            } => Definition {
-                kind: DefinitionKind::Function(stmt),
-                docstring: expr,
-            },
-            VisibleScope {
-                modifier: Modifier::Class,
-                ..
-            } => Definition {
-                kind: DefinitionKind::Method(stmt),
-                docstring: expr,
-            },
-            VisibleScope {
-                modifier: Modifier::Function,
-                ..
-            } => Definition {
-                kind: DefinitionKind::NestedFunction(stmt),
-                docstring: expr,
-            },
-        },
-        Documentable::Class => match scope {
-            VisibleScope {
-                modifier: Modifier::Module,
-                ..
-            } => Definition {
-                kind: DefinitionKind::Class(stmt),
-                docstring: expr,
-            },
-            VisibleScope {
-                modifier: Modifier::Class,
-                ..
-            } => Definition {
-                kind: DefinitionKind::NestedClass(stmt),
-                docstring: expr,
-            },
-            VisibleScope {
-                modifier: Modifier::Function,
-                ..
-            } => Definition {
-                kind: DefinitionKind::NestedClass(stmt),
-                docstring: expr,
-            },
-        },
-    }
-}
-
-/// Extract the source code range for a docstring.
-pub fn range_for(docstring: &Expr) -> Range {
-    // RustPython currently omits the first quotation mark in a string, so offset the location.
-    Range {
-        location: Location::new(docstring.location.row(), docstring.location.column() - 1),
-        end_location: docstring.end_location,
-    }
-}
+use crate::checks::{Check, CheckCode, CheckKind, Fix};
+use crate::docstrings::definition::{Definition, DefinitionKind};
+use crate::docstrings::google::check_google_section;
+use crate::docstrings::helpers::{
+    indentation, leading_space, SINGLE_QUOTE_PREFIXES, TRIPLE_QUOTE_PREFIXES,
+};
+use crate::docstrings::numpy::check_numpy_section;
+use crate::docstrings::sections::section_contexts;
+use crate::docstrings::styles::SectionStyle;
+use crate::visibility::{is_init, is_magic, is_overload, Visibility};

 /// D100, D101, D102, D103, D104, D105, D106, D107
 pub fn not_missing(
@@ -216,7 +138,10 @@ pub fn one_liner(checker: &mut Checker, definition: &Definition) {
            }

            if non_empty_line_count == 1 && line_count > 1 {
-                checker.add_check(Check::new(CheckKind::FitsOnOneLine, range_for(docstring)));
+                checker.add_check(Check::new(
+                    CheckKind::FitsOnOneLine,
+                    Range::from_located(docstring),
+                ));
            }
        }
    }
@@ -239,9 +164,10 @@ pub fn blank_before_after_function(checker: &mut Checker, definition: &Definitio
                ..
            } = &docstring.node
            {
-                let (before, _, after) = checker
-                    .locator
-                    .partition_source_code_at(&Range::from_located(parent), &range_for(docstring));
+                let (before, _, after) = checker.locator.partition_source_code_at(
+                    &Range::from_located(parent),
+                    &Range::from_located(docstring),
+                );

                if checker.settings.enabled.contains(&CheckCode::D201) {
                    let blank_lines_before = before
@@ -251,35 +177,57 @@ pub fn blank_before_after_function(checker: &mut Checker, definition: &Definitio
                        .take_while(|line| line.trim().is_empty())
                        .count();
                    if blank_lines_before != 0 {
-                        checker.add_check(Check::new(
+                        let mut check = Check::new(
                            CheckKind::NoBlankLineBeforeFunction(blank_lines_before),
-                            range_for(docstring),
-                        ));
+                            Range::from_located(docstring),
+                        );
+                        if matches!(checker.autofix, fixer::Mode::Generate | fixer::Mode::Apply) {
+                            check.amend(Fix::deletion(
+                                Location::new(docstring.location.row() - blank_lines_before, 1),
+                                Location::new(docstring.location.row(), 1),
+                            ));
+                        }
+                        checker.add_check(check);
                    }
                }

                if checker.settings.enabled.contains(&CheckCode::D202) {
+                    let all_blank_after = after
+                        .lines()
+                        .skip(1)
+                        .all(|line| line.trim().is_empty() || COMMENT_REGEX.is_match(line));
+                    if all_blank_after {
+                        return;
+                    }
+
                    let blank_lines_after = after
                        .lines()
                        .skip(1)
                        .take_while(|line| line.trim().is_empty())
                        .count();
-                    let all_blank_after = after
-                        .lines()
-                        .skip(1)
-                        .all(|line| line.trim().is_empty() || COMMENT_REGEX.is_match(line));
-                    // Report a D202 violation if the docstring is followed by a blank line
-                    // and the blank line is not itself followed by an inner function or
-                    // class.
-                    if !all_blank_after
-                        && blank_lines_after != 0
-                        && !(blank_lines_after == 1
-                            && INNER_FUNCTION_OR_CLASS_REGEX.is_match(after))
-                    {
-                        checker.add_check(Check::new(
+                    // Report a D202 violation if the docstring is followed by a blank line and the
+                    // blank line is not itself followed by an inner function or class.
+                    let expected_blank_lines_after =
+                        if INNER_FUNCTION_OR_CLASS_REGEX.is_match(after) {
+                            1
+                        } else {
+                            0
+                        };
+                    if blank_lines_after != expected_blank_lines_after {
+                        let mut check = Check::new(
                            CheckKind::NoBlankLineAfterFunction(blank_lines_after),
-                            range_for(docstring),
-                        ));
+                            Range::from_located(docstring),
+                        );
+                        if matches!(checker.autofix, fixer::Mode::Generate | fixer::Mode::Apply) {
+                            check.amend(Fix::deletion(
+                                Location::new(
+                                    docstring.location.row() + 1 + expected_blank_lines_after,
+                                    1,
+                                ),
+                                Location::new(docstring.location.row() + 1 + blank_lines_after, 1),
+                            ));
+                        }
+                        checker.add_check(check);
                    }
                }
            }
@@ -298,9 +246,10 @@ pub fn blank_before_after_class(checker: &mut Checker, definition: &Definition)
                ..
            } = &docstring.node
            {
-                let (before, _, after) = checker
-                    .locator
-                    .partition_source_code_at(&Range::from_located(parent), &range_for(docstring));
+                let (before, _, after) = checker.locator.partition_source_code_at(
+                    &Range::from_located(parent),
+                    &Range::from_located(docstring),
+                );

                if checker.settings.enabled.contains(&CheckCode::D203)
                    || checker.settings.enabled.contains(&CheckCode::D211)
@@ -311,39 +260,71 @@ pub fn blank_before_after_class(checker: &mut Checker, definition: &Definition)
                        .skip(1)
                        .take_while(|line| line.trim().is_empty())
                        .count();
-                    if blank_lines_before != 0
-                        && checker.settings.enabled.contains(&CheckCode::D211)
-                    {
-                        checker.add_check(Check::new(
-                            CheckKind::NoBlankLineBeforeClass(blank_lines_before),
-                            range_for(docstring),
-                        ));
+                    if checker.settings.enabled.contains(&CheckCode::D211) {
+                        if blank_lines_before != 0 {
+                            let mut check = Check::new(
+                                CheckKind::NoBlankLineBeforeClass(blank_lines_before),
+                                Range::from_located(docstring),
+                            );
+                            if matches!(checker.autofix, fixer::Mode::Generate | fixer::Mode::Apply)
+                            {
+                                check.amend(Fix::deletion(
+                                    Location::new(docstring.location.row() - blank_lines_before, 1),
+                                    Location::new(docstring.location.row(), 1),
+                                ));
+                            }
+                            checker.add_check(check);
+                        }
                    }
-                    if blank_lines_before != 1
-                        && checker.settings.enabled.contains(&CheckCode::D203)
-                    {
-                        checker.add_check(Check::new(
-                            CheckKind::OneBlankLineBeforeClass(blank_lines_before),
-                            range_for(docstring),
-                        ));
+                    if checker.settings.enabled.contains(&CheckCode::D203) {
+                        if blank_lines_before != 1 {
+                            let mut check = Check::new(
+                                CheckKind::OneBlankLineBeforeClass(blank_lines_before),
+                                Range::from_located(docstring),
+                            );
+                            if matches!(checker.autofix, fixer::Mode::Generate | fixer::Mode::Apply)
+                            {
+                                check.amend(Fix::replacement(
+                                    "\n".to_string(),
+                                    Location::new(docstring.location.row() - blank_lines_before, 1),
+                                    Location::new(docstring.location.row(), 1),
+                                ));
+                            }
+                            checker.add_check(check);
+                        }
                    }
                }

                if checker.settings.enabled.contains(&CheckCode::D204) {
+                    let all_blank_after = after
+                        .lines()
+                        .skip(1)
+                        .all(|line| line.trim().is_empty() || COMMENT_REGEX.is_match(line));
+                    if all_blank_after {
+                        return;
+                    }
+
                    let blank_lines_after = after
                        .lines()
                        .skip(1)
                        .take_while(|line| line.trim().is_empty())
                        .count();
-                    let all_blank_after = after
-                        .lines()
-                        .skip(1)
-                        .all(|line| line.trim().is_empty() || COMMENT_REGEX.is_match(line));
-                    if !all_blank_after && blank_lines_after != 1 {
-                        checker.add_check(Check::new(
+                    if blank_lines_after != 1 {
+                        let mut check = Check::new(
                            CheckKind::OneBlankLineAfterClass(blank_lines_after),
-                            range_for(docstring),
-                        ));
+                            Range::from_located(docstring),
+                        );
+                        if matches!(checker.autofix, fixer::Mode::Generate | fixer::Mode::Apply) {
+                            check.amend(Fix::replacement(
+                                "\n".to_string(),
+                                Location::new(docstring.end_location.row() + 1, 1),
+                                Location::new(
+                                    docstring.end_location.row() + 1 + blank_lines_after,
+                                    1,
+                                ),
+                            ));
+                        }
+                        checker.add_check(check);
                    }
                }
            }
@@ -370,10 +351,101 @@ pub fn blank_after_summary(checker: &mut Checker, definition: &Definition) {
                }
            }
            if lines_count > 1 && blanks_count != 1 {
-                checker.add_check(Check::new(
+                let mut check = Check::new(
                    CheckKind::NoBlankLineAfterSummary,
-                    range_for(docstring),
-                ));
+                    Range::from_located(docstring),
+                );
+                if matches!(checker.autofix, fixer::Mode::Generate | fixer::Mode::Apply) {
+                    check.amend(Fix::replacement(
+                        "\n".to_string(),
+                        Location::new(docstring.location.row() + 1, 1),
+                        Location::new(docstring.location.row() + 1 + blanks_count, 1),
+                    ));
+                }
+                checker.add_check(check);
+            }
+        }
+    }
+}
+
+/// D206, D207, D208
+pub fn indent(checker: &mut Checker, definition: &Definition) {
+    if let Some(docstring) = definition.docstring {
+        if let ExprKind::Constant {
+            value: Constant::Str(string),
+            ..
+        } = &docstring.node
+        {
+            let lines: Vec<&str> = string.lines().collect();
+            if lines.len() <= 1 {
+                return;
+            }
+
+            let mut has_seen_tab = false;
+            let mut has_seen_over_indent = false;
+            let mut has_seen_under_indent = false;
+
+            let docstring_indent = indentation(checker, docstring).to_string();
+            if !has_seen_tab {
+                if docstring_indent.contains('\t') {
+                    if checker.settings.enabled.contains(&CheckCode::D206) {
+                        checker.add_check(Check::new(
+                            CheckKind::IndentWithSpaces,
+                            Range::from_located(docstring),
+                        ));
+                    }
+                    has_seen_tab = true;
+                }
+            }
+
+            for i in 0..lines.len() {
+                // First lines and continuations doesn't need any indentation.
+                if i == 0 || lines[i - 1].ends_with('\\') {
+                    continue;
+                }
+
+                // Omit empty lines, except for the last line, which is non-empty by way of
+                // containing the closing quotation marks.
+                if i < lines.len() - 1 && lines[i].trim().is_empty() {
+                    continue;
+                }
+
+                let line_indent = leading_space(lines[i]);
+                if !has_seen_tab {
+                    if line_indent.contains('\t') {
+                        if checker.settings.enabled.contains(&CheckCode::D206) {
+                            checker.add_check(Check::new(
+                                CheckKind::IndentWithSpaces,
+                                Range::from_located(docstring),
+                            ));
+                        }
+                        has_seen_tab = true;
+                    }
+                }
+
+                if !has_seen_over_indent {
+                    if line_indent.len() > docstring_indent.len() {
+                        if checker.settings.enabled.contains(&CheckCode::D208) {
+                            checker.add_check(Check::new(
+                                CheckKind::NoOverIndentation,
+                                Range::from_located(docstring),
+                            ));
+                        }
+                        has_seen_over_indent = true;
+                    }
+                }
+
+                if !has_seen_under_indent {
+                    if line_indent.len() < docstring_indent.len() {
+                        if checker.settings.enabled.contains(&CheckCode::D207) {
+                            checker.add_check(Check::new(
+                                CheckKind::NoUnderIndentation,
+                                Range::from_located(docstring),
+                            ));
+                        }
+                        has_seen_under_indent = true;
+                    }
+                }
            }
        }
    }
@@ -395,14 +467,27 @@ pub fn newline_after_last_paragraph(checker: &mut Checker, definition: &Definiti
                if line_count > 1 {
                    let content = checker
                        .locator
-                        .slice_source_code_range(&range_for(docstring));
-                    if let Some(line) = content.lines().last() {
-                        let line = line.trim();
-                        if line != "\"\"\"" && line != "'''" {
-                            checker.add_check(Check::new(
+                        .slice_source_code_range(&Range::from_located(docstring));
+                    if let Some(last_line) = content.lines().last().map(|line| line.trim()) {
+                        if last_line != "\"\"\"" && last_line != "'''" {
+                            let mut check = Check::new(
                                CheckKind::NewLineAfterLastParagraph,
-                                range_for(docstring),
-                            ));
+                                Range::from_located(docstring),
+                            );
+                            if matches!(checker.autofix, fixer::Mode::Generate | fixer::Mode::Apply)
+                            {
+                                // Insert a newline just before the end-quote(s).
+                                let mut content = "\n".to_string();
+                                content.push_str(indentation(checker, docstring));
+                                check.amend(Fix::insertion(
+                                    content,
+                                    Location::new(
+                                        docstring.end_location.row(),
+                                        docstring.end_location.column() - "\"\"\"".len(),
+                                    ),
+                                ));
+                            }
+                            checker.add_check(check);
                        }
                    }
                    return;
@@ -422,14 +507,45 @@ pub fn no_surrounding_whitespace(checker: &mut Checker, definition: &Definition)
        {
            let mut lines = string.lines();
            if let Some(line) = lines.next() {
-                if line.trim().is_empty() {
+                let trimmed = line.trim();
+                if trimmed.is_empty() {
                    return;
                }
-                if line.starts_with(' ') || (matches!(lines.next(), None) && line.ends_with(' ')) {
-                    checker.add_check(Check::new(
+                if line != trimmed {
+                    let mut check = Check::new(
                        CheckKind::NoSurroundingWhitespace,
-                        range_for(docstring),
-                    ));
+                        Range::from_located(docstring),
+                    );
+                    if matches!(checker.autofix, fixer::Mode::Generate | fixer::Mode::Apply) {
+                        if let Some(first_line) = checker
+                            .locator
+                            .slice_source_code_range(&Range::from_located(docstring))
+                            .lines()
+                            .next()
+                            .map(|line| line.to_lowercase())
+                        {
+                            for pattern in TRIPLE_QUOTE_PREFIXES.iter().chain(SINGLE_QUOTE_PREFIXES)
+                            {
+                                if first_line.starts_with(pattern) {
+                                    check.amend(Fix::replacement(
+                                        trimmed.to_string(),
+                                        Location::new(
+                                            docstring.location.row(),
+                                            docstring.location.column() + pattern.len(),
+                                        ),
+                                        Location::new(
+                                            docstring.location.row(),
+                                            docstring.location.column()
+                                                + pattern.len()
+                                                + line.chars().count(),
+                                        ),
+                                    ));
+                                    break;
+                                }
+                            }
+                        }
+                    }
+                    checker.add_check(check);
                }
            }
        }
@@ -445,23 +561,27 @@ pub fn multi_line_summary_start(checker: &mut Checker, definition: &Definition)
        } = &docstring.node
        {
            if string.lines().nth(1).is_some() {
-                let content = checker
+                if let Some(first_line) = checker
                    .locator
-                    .slice_source_code_range(&range_for(docstring));
-                if let Some(first_line) = content.lines().next() {
-                    let first_line = first_line.trim();
-                    if first_line == "\"\"\"" || first_line == "'''" {
+                    .slice_source_code_range(&Range::from_located(docstring))
+                    .lines()
+                    .next()
+                    .map(|line| line.to_lowercase())
+                {
+                    if TRIPLE_QUOTE_PREFIXES.contains(&first_line.as_str()) {
                        if checker.settings.enabled.contains(&CheckCode::D212) {
                            checker.add_check(Check::new(
                                CheckKind::MultiLineSummaryFirstLine,
-                                range_for(docstring),
+                                Range::from_located(docstring),
+                            ));
+                        }
+                    } else {
+                        if checker.settings.enabled.contains(&CheckCode::D213) {
+                            checker.add_check(Check::new(
+                                CheckKind::MultiLineSummarySecondLine,
+                                Range::from_located(docstring),
                            ));
                        }
-                    } else if checker.settings.enabled.contains(&CheckCode::D213) {
-                        checker.add_check(Check::new(
-                            CheckKind::MultiLineSummarySecondLine,
-                            range_for(docstring),
-                        ));
                    }
                }
            }
@@ -477,21 +597,30 @@ pub fn triple_quotes(checker: &mut Checker, definition: &Definition) {
            ..
        } = &docstring.node
        {
-            let content = checker
+            if let Some(first_line) = checker
                .locator
-                .slice_source_code_range(&range_for(docstring));
-            if string.contains("\"\"\"") {
-                if !content.starts_with("'''") {
+                .slice_source_code_range(&Range::from_located(docstring))
+                .lines()
+                .next()
+                .map(|line| line.to_lowercase())
+            {
+                let starts_with_triple = if string.contains("\"\"\"") {
+                    first_line.starts_with("'''")
+                        || first_line.starts_with("u'''")
+                        || first_line.starts_with("r'''")
+                        || first_line.starts_with("ur'''")
+                } else {
+                    first_line.starts_with("\"\"\"")
+                        || first_line.starts_with("u\"\"\"")
+                        || first_line.starts_with("r\"\"\"")
+                        || first_line.starts_with("ur\"\"\"")
+                };
+                if !starts_with_triple {
                    checker.add_check(Check::new(
                        CheckKind::UsesTripleQuotes,
-                        range_for(docstring),
+                        Range::from_located(docstring),
                    ));
                }
-            } else if !content.starts_with("\"\"\"") {
-                checker.add_check(Check::new(
-                    CheckKind::UsesTripleQuotes,
-                    range_for(docstring),
-                ));
            }
        }
    }
@@ -507,7 +636,10 @@ pub fn ends_with_period(checker: &mut Checker, definition: &Definition) {
        {
            if let Some(string) = string.lines().next() {
                if !string.ends_with('.') {
-                    checker.add_check(Check::new(CheckKind::EndsInPeriod, range_for(docstring)));
+                    checker.add_check(Check::new(
+                        CheckKind::EndsInPeriod,
+                        Range::from_located(docstring),
+                    ));
                }
            }
        }
@@ -531,7 +663,7 @@ pub fn no_signature(checker: &mut Checker, definition: &Definition) {
                        if first_line.contains(&format!("{name}(")) {
                            checker.add_check(Check::new(
                                CheckKind::NoSignature,
-                                range_for(docstring),
+                                Range::from_located(docstring),
                            ));
                        }
                    }
@@ -566,7 +698,7 @@ pub fn capitalized(checker: &mut Checker, definition: &Definition) {
                    if !first_char.is_uppercase() {
                        checker.add_check(Check::new(
                            CheckKind::FirstLineCapitalized,
-                            range_for(docstring),
+                            Range::from_located(docstring),
                        ));
                    }
                }
@@ -594,7 +726,10 @@ pub fn starts_with_this(checker: &mut Checker, definition: &Definition) {
                    .to_lowercase()
                    == "this"
                {
-                    checker.add_check(Check::new(CheckKind::NoThisPrefix, range_for(docstring)));
+                    checker.add_check(Check::new(
+                        CheckKind::NoThisPrefix,
+                        Range::from_located(docstring),
+                    ));
                }
            }
        }
@@ -613,7 +748,7 @@ pub fn ends_with_punctuation(checker: &mut Checker, definition: &Definition) {
                if !(string.ends_with('.') || string.ends_with('!') || string.ends_with('?')) {
                    checker.add_check(Check::new(
                        CheckKind::EndsInPunctuation,
-                        range_for(docstring),
+                        Range::from_located(docstring),
                    ));
                }
            }
@@ -648,7 +783,10 @@ pub fn not_empty(checker: &mut Checker, definition: &Definition) -> bool {
        {
            if string.trim().is_empty() {
                if checker.settings.enabled.contains(&CheckCode::D419) {
-                    checker.add_check(Check::new(CheckKind::NonEmpty, range_for(docstring)));
+                    checker.add_check(Check::new(
+                        CheckKind::NonEmpty,
+                        Range::from_located(docstring),
+                    ));
                }
                return false;
            }
@@ -657,7 +795,8 @@ pub fn not_empty(checker: &mut Checker, definition: &Definition) -> bool {
    true
 }

-pub fn check_sections(checker: &mut Checker, definition: &Definition) {
+/// D212, D214, D215, D405, D406, D407, D408, D409, D410, D411, D412, D413, D414, D416, D417
+pub fn sections(checker: &mut Checker, definition: &Definition) {
    if let Some(docstring) = definition.docstring {
        if let ExprKind::Constant {
            value: Constant::Str(string),
@@ -668,9 +807,20 @@ pub fn check_sections(checker: &mut Checker, definition: &Definition) {
            if lines.len() < 2 {
                return;
            }
-            for context in &section_contexts(&lines) {
+
+            // First, interpret as NumPy-style sections.
+            let mut found_numpy_section = false;
+            for context in &section_contexts(&lines, &SectionStyle::NumPy) {
+                found_numpy_section = true;
                check_numpy_section(checker, definition, context);
            }
+
+            // If no such sections were identified, interpret as Google-style sections.
+            if !found_numpy_section {
+                for context in &section_contexts(&lines, &SectionStyle::Google) {
+                    check_google_section(checker, definition, context);
+                }
+            }
        }
    }
 }
--- a/src/docstrings/sections.rs
+++ b/src/docstrings/sections.rs
@@ -1,120 +1,32 @@
-use itertools::Itertools;
 use std::collections::BTreeSet;

-use once_cell::sync::Lazy;
-use rustpython_ast::{Arg, Expr, Location, StmtKind};
+use itertools::Itertools;
+use rustpython_ast::{Arg, Location, StmtKind};
 use titlecase::titlecase;

 use crate::ast::types::Range;
+use crate::autofix::fixer;
 use crate::check_ast::Checker;
-use crate::checks::{Check, CheckCode, CheckKind};
-use crate::docstrings::docstring_checks::range_for;
-use crate::docstrings::types::{Definition, DefinitionKind};
+use crate::checks::{Check, CheckCode, CheckKind, Fix};
+use crate::docstrings::definition::{Definition, DefinitionKind};
+use crate::docstrings::helpers;
+use crate::docstrings::styles::SectionStyle;
 use crate::visibility::is_static;

-static NUMPY_SECTION_NAMES: Lazy<BTreeSet<&'static str>> = Lazy::new(|| {
-    BTreeSet::from([
-        "Short Summary",
-        "Extended Summary",
-        "Parameters",
-        "Returns",
-        "Yields",
-        "Other Parameters",
-        "Raises",
-        "See Also",
-        "Notes",
-        "References",
-        "Examples",
-        "Attributes",
-        "Methods",
-    ])
-});
-
-static NUMPY_SECTION_NAMES_LOWERCASE: Lazy<BTreeSet<&'static str>> = Lazy::new(|| {
-    BTreeSet::from([
-        "short summary",
-        "extended summary",
-        "parameters",
-        "returns",
-        "yields",
-        "other parameters",
-        "raises",
-        "see also",
-        "notes",
-        "references",
-        "examples",
-        "attributes",
-        "methods",
-    ])
-});
-
-// TODO(charlie): Include Google section names.
-// static GOOGLE_SECTION_NAMES: Lazy<BTreeSet<&'static str>> = Lazy::new(|| {
-//     BTreeSet::from([
-//         "Args",
-//         "Arguments",
-//         "Attention",
-//         "Attributes",
-//         "Caution",
-//         "Danger",
-//         "Error",
-//         "Example",
-//         "Examples",
-//         "Hint",
-//         "Important",
-//         "Keyword Args",
-//         "Keyword Arguments",
-//         "Methods",
-//         "Note",
-//         "Notes",
-//         "Return",
-//         "Returns",
-//         "Raises",
-//         "References",
-//         "See Also",
-//         "Tip",
-//         "Todo",
-//         "Warning",
-//         "Warnings",
-//         "Warns",
-//         "Yield",
-//         "Yields",
-//     ])
-// });
-
-fn indentation<'a>(checker: &'a mut Checker, docstring: &Expr) -> &'a str {
-    let range = range_for(docstring);
-    checker.locator.slice_source_code_range(&Range {
-        location: Location::new(range.location.row(), 1),
-        end_location: Location::new(range.location.row(), range.location.column()),
-    })
-}
-
-fn leading_space(line: &str) -> String {
-    line.chars()
-        .take_while(|char| char.is_whitespace())
-        .collect()
-}
-
-fn leading_words(line: &str) -> String {
-    line.trim()
-        .chars()
-        .take_while(|char| char.is_alphanumeric() || char.is_whitespace())
-        .collect()
-}
-
-fn suspected_as_section(line: &str) -> bool {
-    NUMPY_SECTION_NAMES_LOWERCASE.contains(&leading_words(line).to_lowercase().as_str())
-}
-
 #[derive(Debug)]
-pub struct SectionContext<'a> {
-    section_name: String,
-    previous_line: &'a str,
-    line: &'a str,
-    following_lines: &'a [&'a str],
+pub(crate) struct SectionContext<'a> {
+    pub(crate) section_name: String,
+    pub(crate) previous_line: &'a str,
+    pub(crate) line: &'a str,
+    pub(crate) following_lines: &'a [&'a str],
+    pub(crate) is_last_section: bool,
    original_index: usize,
-    is_last_section: bool,
+}
+
+fn suspected_as_section(line: &str, style: &SectionStyle) -> bool {
+    style
+        .lowercase_section_names()
+        .contains(&helpers::leading_words(line).to_lowercase().as_str())
 }

 /// Check if the suspected context is really a section header.
@@ -145,12 +57,15 @@ fn is_docstring_section(context: &SectionContext) -> bool {
 }

 /// Extract all `SectionContext` values from a docstring.
-pub fn section_contexts<'a>(lines: &'a [&'a str]) -> Vec<SectionContext<'a>> {
+pub(crate) fn section_contexts<'a>(
+    lines: &'a [&'a str],
+    style: &SectionStyle,
+) -> Vec<SectionContext<'a>> {
    let suspected_section_indices: Vec<usize> = lines
        .iter()
        .enumerate()
        .filter_map(|(lineno, line)| {
-            if lineno > 0 && suspected_as_section(line) {
+            if lineno > 0 && suspected_as_section(line, style) {
                Some(lineno)
            } else {
                None
@@ -161,7 +76,7 @@ pub fn section_contexts<'a>(lines: &'a [&'a str]) -> Vec<SectionContext<'a>> {
    let mut contexts = vec![];
    for lineno in suspected_section_indices {
        let context = SectionContext {
-            section_name: leading_words(lines[lineno]),
+            section_name: helpers::leading_words(lines[lineno]),
            previous_line: lines[lineno - 1],
            line: lines[lineno],
            following_lines: &lines[lineno + 1..],
@@ -217,13 +132,13 @@ fn check_blanks_and_section_underline(
        if checker.settings.enabled.contains(&CheckCode::D407) {
            checker.add_check(Check::new(
                CheckKind::DashedUnderlineAfterSection(context.section_name.to_string()),
-                range_for(docstring),
+                Range::from_located(docstring),
            ));
        }
        if checker.settings.enabled.contains(&CheckCode::D414) {
            checker.add_check(Check::new(
                CheckKind::NonEmptySection(context.section_name.to_string()),
-                range_for(docstring),
+                Range::from_located(docstring),
            ));
        }
        return;
@@ -238,7 +153,7 @@ fn check_blanks_and_section_underline(
        if checker.settings.enabled.contains(&CheckCode::D407) {
            checker.add_check(Check::new(
                CheckKind::DashedUnderlineAfterSection(context.section_name.to_string()),
-                range_for(docstring),
+                Range::from_located(docstring),
            ));
        }
        if blank_lines_after_header > 0 {
@@ -247,7 +162,7 @@ fn check_blanks_and_section_underline(
                    CheckKind::NoBlankLinesBetweenHeaderAndContent(
                        context.section_name.to_string(),
                    ),
-                    range_for(docstring),
+                    Range::from_located(docstring),
                ));
            }
        }
@@ -256,7 +171,7 @@ fn check_blanks_and_section_underline(
            if checker.settings.enabled.contains(&CheckCode::D408) {
                checker.add_check(Check::new(
                    CheckKind::SectionUnderlineAfterName(context.section_name.to_string()),
-                    range_for(docstring),
+                    Range::from_located(docstring),
                ));
            }
        }
@@ -273,16 +188,18 @@ fn check_blanks_and_section_underline(
                    CheckKind::SectionUnderlineMatchesSectionLength(
                        context.section_name.to_string(),
                    ),
-                    range_for(docstring),
+                    Range::from_located(docstring),
                ));
            }
        }

        if checker.settings.enabled.contains(&CheckCode::D215) {
-            if leading_space(non_empty_line).len() > indentation(checker, docstring).len() {
+            if helpers::leading_space(non_empty_line).len()
+                > helpers::indentation(checker, docstring).len()
+            {
                checker.add_check(Check::new(
                    CheckKind::SectionUnderlineNotOverIndented(context.section_name.to_string()),
-                    range_for(docstring),
+                    Range::from_located(docstring),
                ));
            }
        }
@@ -297,7 +214,7 @@ fn check_blanks_and_section_underline(
                    if checker.settings.enabled.contains(&CheckCode::D414) {
                        checker.add_check(Check::new(
                            CheckKind::NonEmptySection(context.section_name.to_string()),
-                            range_for(docstring),
+                            Range::from_located(docstring),
                        ));
                    }
                } else {
@@ -306,7 +223,7 @@ fn check_blanks_and_section_underline(
                            CheckKind::NoBlankLinesBetweenHeaderAndContent(
                                context.section_name.to_string(),
                            ),
-                            range_for(docstring),
+                            Range::from_located(docstring),
                        ));
                    }
                }
@@ -315,34 +232,45 @@ fn check_blanks_and_section_underline(
            if checker.settings.enabled.contains(&CheckCode::D414) {
                checker.add_check(Check::new(
                    CheckKind::NonEmptySection(context.section_name.to_string()),
-                    range_for(docstring),
+                    Range::from_located(docstring),
                ));
            }
        }
    }
 }

-fn check_common_section(checker: &mut Checker, definition: &Definition, context: &SectionContext) {
+pub(crate) fn check_common_section(
+    checker: &mut Checker,
+    definition: &Definition,
+    context: &SectionContext,
+    style: &SectionStyle,
+) {
    let docstring = definition
        .docstring
        .expect("Sections are only available for docstrings.");

    if checker.settings.enabled.contains(&CheckCode::D405) {
-        if !NUMPY_SECTION_NAMES.contains(&context.section_name.as_str())
-            && NUMPY_SECTION_NAMES.contains(titlecase(&context.section_name).as_str())
+        if !style
+            .section_names()
+            .contains(&context.section_name.as_str())
+            && style
+                .section_names()
+                .contains(titlecase(&context.section_name).as_str())
        {
            checker.add_check(Check::new(
                CheckKind::CapitalizeSectionName(context.section_name.to_string()),
-                range_for(docstring),
+                Range::from_located(docstring),
            ))
        }
    }

    if checker.settings.enabled.contains(&CheckCode::D214) {
-        if leading_space(context.line).len() > indentation(checker, docstring).len() {
+        if helpers::leading_space(context.line).len()
+            > helpers::indentation(checker, docstring).len()
+        {
            checker.add_check(Check::new(
                CheckKind::SectionNotOverIndented(context.section_name.to_string()),
-                range_for(docstring),
+                Range::from_located(docstring),
            ))
        }
    }
@@ -355,17 +283,43 @@ fn check_common_section(checker: &mut Checker, definition: &Definition, context:
    {
        if context.is_last_section {
            if checker.settings.enabled.contains(&CheckCode::D413) {
-                checker.add_check(Check::new(
+                let mut check = Check::new(
                    CheckKind::BlankLineAfterLastSection(context.section_name.to_string()),
-                    range_for(docstring),
-                ))
+                    Range::from_located(docstring),
+                );
+                if matches!(checker.autofix, fixer::Mode::Generate | fixer::Mode::Apply) {
+                    check.amend(Fix::insertion(
+                        "\n".to_string(),
+                        Location::new(
+                            docstring.location.row()
+                                + context.original_index
+                                + 1
+                                + context.following_lines.len(),
+                            1,
+                        ),
+                    ))
+                }
+                checker.add_check(check);
            }
        } else {
            if checker.settings.enabled.contains(&CheckCode::D410) {
-                checker.add_check(Check::new(
+                let mut check = Check::new(
                    CheckKind::BlankLineAfterSection(context.section_name.to_string()),
-                    range_for(docstring),
-                ))
+                    Range::from_located(docstring),
+                );
+                if matches!(checker.autofix, fixer::Mode::Generate | fixer::Mode::Apply) {
+                    check.amend(Fix::insertion(
+                        "\n".to_string(),
+                        Location::new(
+                            docstring.location.row()
+                                + context.original_index
+                                + 1
+                                + context.following_lines.len(),
+                            1,
+                        ),
+                    ))
+                }
+                checker.add_check(check);
            }
        }
    }
@@ -374,16 +328,18 @@ fn check_common_section(checker: &mut Checker, definition: &Definition, context:
        if !context.previous_line.is_empty() {
            checker.add_check(Check::new(
                CheckKind::BlankLineBeforeSection(context.section_name.to_string()),
-                range_for(docstring),
+                Range::from_located(docstring),
            ))
        }
    }
+
+    check_blanks_and_section_underline(checker, definition, context);
 }

-fn check_missing_args(
+pub(crate) fn check_missing_args(
    checker: &mut Checker,
    definition: &Definition,
-    docstrings_args: BTreeSet<&str>,
+    docstrings_args: &BTreeSet<&str>,
 ) {
    if let DefinitionKind::Function(parent)
    | DefinitionKind::NestedFunction(parent)
@@ -445,68 +401,3 @@ fn check_missing_args(
        }
    }
 }
-
-fn check_parameters_section(
-    checker: &mut Checker,
-    definition: &Definition,
-    context: &SectionContext,
-) {
-    // Collect the list of arguments documented in the docstring.
-    let mut docstring_args: BTreeSet<&str> = Default::default();
-    let section_level_indent = leading_space(context.line);
-    for i in 1..context.following_lines.len() {
-        let current_line = context.following_lines[i - 1];
-        let current_leading_space = leading_space(current_line);
-        let next_line = context.following_lines[i];
-        if current_leading_space == section_level_indent
-            && (leading_space(next_line).len() > current_leading_space.len())
-            && !next_line.trim().is_empty()
-        {
-            let parameters = if let Some(semi_index) = current_line.find(':') {
-                // If the parameter has a type annotation, exclude it.
-                &current_line[..semi_index]
-            } else {
-                // Otherwise, it's just a list of parameters on the current line.
-                current_line.trim()
-            };
-            // Notably, NumPy lets you put multiple parameters of the same type on the same line.
-            for parameter in parameters.split(',') {
-                docstring_args.insert(parameter.trim());
-            }
-        }
-    }
-    // Validate that all arguments were documented.
-    check_missing_args(checker, definition, docstring_args);
-}
-
-pub fn check_numpy_section(
-    checker: &mut Checker,
-    definition: &Definition,
-    context: &SectionContext,
-) {
-    check_common_section(checker, definition, context);
-    check_blanks_and_section_underline(checker, definition, context);
-
-    if checker.settings.enabled.contains(&CheckCode::D406) {
-        let suffix = context
-            .line
-            .trim()
-            .strip_prefix(&context.section_name)
-            .unwrap();
-        if !suffix.is_empty() {
-            let docstring = definition
-                .docstring
-                .expect("Sections are only available for docstrings.");
-            checker.add_check(Check::new(
-                CheckKind::NewLineAfterSectionName(context.section_name.to_string()),
-                range_for(docstring),
-            ))
-        }
-    }
-
-    if checker.settings.enabled.contains(&CheckCode::D417) {
-        if titlecase(&context.section_name) == "Parameters" {
-            check_parameters_section(checker, definition, context);
-        }
-    }
-}
--- a/src/docstrings/styles.rs
+++ b/src/docstrings/styles.rs
@@ -0,0 +1,27 @@
+use std::collections::BTreeSet;
+
+use once_cell::sync::Lazy;
+
+use crate::docstrings::google::{GOOGLE_SECTION_NAMES, LOWERCASE_GOOGLE_SECTION_NAMES};
+use crate::docstrings::numpy::{LOWERCASE_NUMPY_SECTION_NAMES, NUMPY_SECTION_NAMES};
+
+pub(crate) enum SectionStyle {
+    NumPy,
+    Google,
+}
+
+impl SectionStyle {
+    pub(crate) fn section_names(&self) -> &Lazy<BTreeSet<&'static str>> {
+        match self {
+            SectionStyle::NumPy => &NUMPY_SECTION_NAMES,
+            SectionStyle::Google => &GOOGLE_SECTION_NAMES,
+        }
+    }
+
+    pub(crate) fn lowercase_section_names(&self) -> &Lazy<BTreeSet<&'static str>> {
+        match self {
+            SectionStyle::NumPy => &LOWERCASE_NUMPY_SECTION_NAMES,
+            SectionStyle::Google => &LOWERCASE_GOOGLE_SECTION_NAMES,
+        }
+    }
+}
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1,4 +1,5 @@
 #![allow(clippy::collapsible_if, clippy::collapsible_else_if)]
+
 use std::path::Path;

 use anyhow::Result;
--- a/src/linter.rs
+++ b/src/linter.rs
@@ -4,6 +4,7 @@ use std::io::Write;
 use std::path::Path;

 use anyhow::Result;
+#[cfg(not(target_family = "wasm"))]
 use log::debug;
 use rustpython_parser::lexer::LexResult;
 use rustpython_parser::{lexer, parser};
@@ -77,7 +78,7 @@ pub(crate) fn check_path(
        if !ignores.is_empty() {
            return Ok(checks
                .into_iter()
-                .filter(|check| !ignores.contains(check.kind.code()))
+                .filter(|check| !ignores.contains(&check.kind.code()))
                .collect());
        }
    }
@@ -122,6 +123,7 @@ pub fn lint_stdin(
        .collect())
 }

+#[cfg_attr(target_family = "wasm", allow(unused_variables))]
 pub fn lint_path(
    path: &Path,
    settings: &Settings,
@@ -131,6 +133,7 @@ pub fn lint_path(
    let metadata = path.metadata()?;

    // Check the cache.
+    #[cfg(not(target_family = "wasm"))]
    if let Some(messages) = cache::get(path, &metadata, settings, autofix, mode) {
        debug!("Cache hit for: {}", path.to_string_lossy());
        return Ok(messages);
@@ -166,6 +169,7 @@ pub fn lint_path(
            filename: path.to_string_lossy().to_string(),
        })
        .collect();
+    #[cfg(not(target_family = "wasm"))]
    cache::set(path, &metadata, settings, autofix, &messages, mode);

    Ok(messages)
@@ -259,6 +263,7 @@ mod tests {
    #[test_case(CheckCode::C414, Path::new("C414.py"); "C414")]
    #[test_case(CheckCode::C415, Path::new("C415.py"); "C415")]
    #[test_case(CheckCode::C416, Path::new("C416.py"); "C416")]
+    #[test_case(CheckCode::C417, Path::new("C417.py"); "C417")]
    #[test_case(CheckCode::D100, Path::new("D.py"); "D100")]
    #[test_case(CheckCode::D101, Path::new("D.py"); "D101")]
    #[test_case(CheckCode::D102, Path::new("D.py"); "D102")]
@@ -272,6 +277,9 @@ mod tests {
    #[test_case(CheckCode::D203, Path::new("D.py"); "D203")]
    #[test_case(CheckCode::D204, Path::new("D.py"); "D204")]
    #[test_case(CheckCode::D205, Path::new("D.py"); "D205")]
+    #[test_case(CheckCode::D206, Path::new("D.py"); "D206")]
+    #[test_case(CheckCode::D207, Path::new("D.py"); "D207")]
+    #[test_case(CheckCode::D208, Path::new("D.py"); "D208")]
    #[test_case(CheckCode::D209, Path::new("D.py"); "D209")]
    #[test_case(CheckCode::D210, Path::new("D.py"); "D210")]
    #[test_case(CheckCode::D211, Path::new("D.py"); "D211")]
@@ -295,8 +303,10 @@ mod tests {
    #[test_case(CheckCode::D413, Path::new("sections.py"); "D413")]
    #[test_case(CheckCode::D414, Path::new("sections.py"); "D414")]
    #[test_case(CheckCode::D415, Path::new("D.py"); "D415")]
+    #[test_case(CheckCode::D416, Path::new("D.py"); "D416")]
    #[test_case(CheckCode::D417, Path::new("sections.py"); "D417_0")]
    #[test_case(CheckCode::D417, Path::new("canonical_numpy_examples.py"); "D417_1")]
+    #[test_case(CheckCode::D417, Path::new("canonical_google_examples.py"); "D417_2")]
    #[test_case(CheckCode::D418, Path::new("D.py"); "D418")]
    #[test_case(CheckCode::D419, Path::new("D.py"); "D419")]
    #[test_case(CheckCode::E402, Path::new("E402.py"); "E402")]
@@ -343,6 +353,11 @@ mod tests {
    #[test_case(CheckCode::F831, Path::new("F831.py"); "F831")]
    #[test_case(CheckCode::F841, Path::new("F841.py"); "F841")]
    #[test_case(CheckCode::F901, Path::new("F901.py"); "F901")]
+    #[test_case(CheckCode::N801, Path::new("N801.py"); "N801")]
+    #[test_case(CheckCode::N802, Path::new("N802.py"); "N802")]
+    #[test_case(CheckCode::N803, Path::new("N803.py"); "N803")]
+    #[test_case(CheckCode::N804, Path::new("N804.py"); "N804")]
+    #[test_case(CheckCode::N805, Path::new("N805.py"); "N805")]
    #[test_case(CheckCode::T201, Path::new("T201.py"); "T201")]
    #[test_case(CheckCode::T203, Path::new("T203.py"); "T203")]
    #[test_case(CheckCode::U001, Path::new("U001.py"); "U001")]
--- a/src/main.rs
+++ b/src/main.rs
@@ -9,9 +9,11 @@ use clap::Parser;
 use colored::Colorize;
 use log::{debug, error};
 use notify::{raw_watcher, RecursiveMode, Watcher};
+#[cfg(not(target_family = "wasm"))]
 use rayon::prelude::*;
 use walkdir::DirEntry;

+#[cfg(not(target_family = "wasm"))]
 use ruff::cache;
 use ruff::checks::CheckCode;
 use ruff::checks::CheckKind;
@@ -29,9 +31,24 @@ use ruff::settings::RawSettings;
 use ruff::settings::{FilePattern, PerFileIgnore, Settings};
 use ruff::tell_user;

+#[cfg(feature = "update-informer")]
 const CARGO_PKG_NAME: &str = env!("CARGO_PKG_NAME");
+#[cfg(feature = "update-informer")]
 const CARGO_PKG_VERSION: &str = env!("CARGO_PKG_VERSION");

+/// Shim that calls par_iter except for wasm because there's no wasm support in rayon yet
+/// (there is a shim to be used for the web, but it requires js cooperation)
+/// Unfortunately, ParallelIterator does not implement Iterator so the signatures diverge
+#[cfg(not(target_family = "wasm"))]
+fn par_iter<T: Sync>(iterable: &Vec<T>) -> impl ParallelIterator<Item = &T> {
+    iterable.par_iter()
+}
+
+#[cfg(target_family = "wasm")]
+fn par_iter<T: Sync>(iterable: &Vec<T>) -> impl Iterator<Item = &T> {
+    iterable.iter()
+}
+
 #[cfg(feature = "update-informer")]
 fn check_for_updates() {
    use update_informer::{registry, Check};
@@ -104,8 +121,7 @@ fn run_once(
    debug!("Identified files to lint in: {:?}", duration);

    let start = Instant::now();
-    let mut messages: Vec<Message> = paths
-        .par_iter()
+    let mut messages: Vec<Message> = par_iter(&paths)
        .map(|entry| {
            match entry {
                Ok(entry) => {
@@ -160,8 +176,7 @@ fn add_noqa(files: &[PathBuf], settings: &Settings) -> Result<usize> {
    debug!("Identified files to lint in: {:?}", duration);

    let start = Instant::now();
-    let modifications: usize = paths
-        .par_iter()
+    let modifications: usize = par_iter(&paths)
        .map(|entry| match entry {
            Ok(entry) => {
                let path = entry.path();
@@ -190,8 +205,7 @@ fn autoformat(files: &[PathBuf], settings: &Settings) -> Result<usize> {
    debug!("Identified files to lint in: {:?}", duration);

    let start = Instant::now();
-    let modifications = paths
-        .par_iter()
+    let modifications = par_iter(&paths)
        .map(|entry| {
            let path = entry.path();
            autoformat_path(path)
@@ -302,6 +316,7 @@ fn inner_main() -> Result<ExitCode> {
        return Ok(ExitCode::SUCCESS);
    }

+    #[cfg(not(target_family = "wasm"))]
    cache::init()?;

    let mut printer = Printer::new(cli.format, cli.verbose);
@@ -367,25 +382,30 @@ fn inner_main() -> Result<ExitCode> {
            println!("Formatted {modifications} files.");
        }
    } else {
-        let (messages, print_messages) = if cli.files == vec![PathBuf::from("-")] {
-            let filename = cli.stdin_filename.unwrap_or_else(|| "-".to_string());
-            let path = Path::new(&filename);
-            (
-                run_once_stdin(&settings, path, cli.fix)?,
-                !cli.quiet && !cli.fix,
-            )
-        } else {
-            (
-                run_once(&cli.files, &settings, !cli.no_cache, cli.fix)?,
-                !cli.quiet,
-            )
-        };
-        if print_messages {
+        let (messages, should_print_messages, should_check_updates) =
+            if cli.files == vec![PathBuf::from("-")] {
+                let filename = cli.stdin_filename.unwrap_or_else(|| "-".to_string());
+                let path = Path::new(&filename);
+                (
+                    run_once_stdin(&settings, path, cli.fix)?,
+                    !cli.quiet && !cli.fix,
+                    false,
+                )
+            } else {
+                (
+                    run_once(&cli.files, &settings, !cli.no_cache, cli.fix)?,
+                    !cli.quiet,
+                    !cli.quiet,
+                )
+            };
+        if should_print_messages {
            printer.write_once(&messages)?;
        }

        #[cfg(feature = "update-informer")]
-        check_for_updates();
+        if should_check_updates {
+            check_for_updates();
+        }

        if messages.iter().any(|message| !message.fixed) && !cli.exit_zero {
            return Ok(ExitCode::FAILURE);
--- a/src/noqa.rs
+++ b/src/noqa.rs
@@ -81,7 +81,7 @@ pub fn extract_noqa_line_for(lxr: &[LexResult]) -> Vec<usize> {
 }

 fn add_noqa_inner(
-    checks: &Vec<Check>,
+    checks: &[Check],
    contents: &str,
    noqa_line_for: &[usize],
 ) -> Result<(usize, String)> {
@@ -138,7 +138,7 @@ fn add_noqa_inner(
 }

 pub fn add_noqa(
-    checks: &Vec<Check>,
+    checks: &[Check],
    contents: &str,
    noqa_line_for: &[usize],
    path: &Path,
--- a/src/plugins/duplicate_exceptions.rs
+++ b/src/plugins/duplicate_exceptions.rs
@@ -24,7 +24,7 @@ fn type_pattern(elts: Vec<&Expr>) -> Expr {
 pub fn duplicate_handler_exceptions(
    checker: &mut Checker,
    expr: &Expr,
-    elts: &Vec<Expr>,
+    elts: &[Expr],
 ) -> BTreeSet<String> {
    let mut seen: BTreeSet<String> = Default::default();
    let mut duplicates: BTreeSet<String> = Default::default();
--- a/src/plugins/super_call_with_parameters.rs
+++ b/src/plugins/super_call_with_parameters.rs
@@ -4,12 +4,7 @@ use crate::ast::{checkers, helpers};
 use crate::autofix::{fixer, fixes};
 use crate::check_ast::Checker;

-pub fn super_call_with_parameters(
-    checker: &mut Checker,
-    expr: &Expr,
-    func: &Expr,
-    args: &Vec<Expr>,
-) {
+pub fn super_call_with_parameters(checker: &mut Checker, expr: &Expr, func: &Expr, args: &[Expr]) {
    // Only bother going through the super check at all if we're in a `super` call.
    // (We check this in `check_super_args` too, so this is just an optimization.)
    if helpers::is_super_call_with_arguments(func, args) {
--- a/src/plugins/type_of_primitive.rs
+++ b/src/plugins/type_of_primitive.rs
@@ -6,7 +6,7 @@ use crate::autofix::fixer;
 use crate::check_ast::Checker;
 use crate::checks::{CheckKind, Fix};

-pub fn type_of_primitive(checker: &mut Checker, expr: &Expr, func: &Expr, args: &Vec<Expr>) {
+pub fn type_of_primitive(checker: &mut Checker, expr: &Expr, func: &Expr, args: &[Expr]) {
    if let Some(mut check) =
        checkers::type_of_primitive(func, args, checker.locate_check(Range::from_located(expr)))
    {
--- a/src/plugins/unnecessary_abspath.rs
+++ b/src/plugins/unnecessary_abspath.rs
@@ -6,7 +6,7 @@ use crate::autofix::fixer;
 use crate::check_ast::Checker;
 use crate::checks::Fix;

-pub fn unnecessary_abspath(checker: &mut Checker, expr: &Expr, func: &Expr, args: &Vec<Expr>) {
+pub fn unnecessary_abspath(checker: &mut Checker, expr: &Expr, func: &Expr, args: &[Expr]) {
    if let Some(mut check) =
        checkers::unnecessary_abspath(func, args, checker.locate_check(Range::from_located(expr)))
    {
--- a/src/plugins/useless_metaclass_type.rs
+++ b/src/plugins/useless_metaclass_type.rs
@@ -6,12 +6,7 @@ use crate::ast::types::{CheckLocator, Range};
 use crate::autofix::{fixer, fixes};
 use crate::check_ast::Checker;

-pub fn useless_metaclass_type(
-    checker: &mut Checker,
-    stmt: &Stmt,
-    value: &Expr,
-    targets: &Vec<Expr>,
-) {
+pub fn useless_metaclass_type(checker: &mut Checker, stmt: &Stmt, value: &Expr, targets: &[Expr]) {
    if let Some(mut check) = checkers::useless_metaclass_type(
        targets,
        value,
--- a/src/printer.rs
+++ b/src/printer.rs
@@ -50,14 +50,14 @@ impl Printer {
                    serde_json::to_string_pretty(
                        &messages
                            .iter()
-                            .map(|m| ExpandedMessage {
-                                kind: &m.kind,
-                                code: m.kind.code(),
-                                message: m.kind.body(),
-                                fixed: m.fixed,
-                                location: m.location,
-                                end_location: m.end_location,
-                                filename: &m.filename,
+                            .map(|message| ExpandedMessage {
+                                kind: &message.kind,
+                                code: message.kind.code(),
+                                message: message.kind.body(),
+                                fixed: message.fixed,
+                                location: message.location,
+                                end_location: message.end_location,
+                                filename: &message.filename,
                            })
                            .collect::<Vec<_>>()
                    )?
@@ -104,6 +104,7 @@ impl Printer {
    }

    pub fn clear_screen(&mut self) -> Result<()> {
+        #[cfg(not(target_family = "wasm"))]
        clearscreen::clear()?;
        Ok(())
    }
--- a/src/settings.rs
+++ b/src/settings.rs
@@ -8,8 +8,9 @@ use glob::Pattern;
 use once_cell::sync::Lazy;
 use regex::Regex;
 use serde::{Deserialize, Serialize};
+use strum::IntoEnumIterator;

-use crate::checks::{CheckCode, DEFAULT_CHECK_CODES};
+use crate::checks::{CheckCategory, CheckCode};
 use crate::fs;
 use crate::pyproject::{load_config, StrCheckCodePair};

@@ -153,9 +154,16 @@ impl RawSettings {
                .map(|path| FilePattern::from_user(path, project_root))
                .collect(),
            extend_ignore: config.extend_ignore,
-            select: config
-                .select
-                .unwrap_or_else(|| DEFAULT_CHECK_CODES.to_vec()),
+            select: config.select.unwrap_or_else(|| {
+                CheckCode::iter()
+                    .filter(|code| {
+                        matches!(
+                            code.category(),
+                            CheckCategory::Pycodestyle | CheckCategory::Pyflakes
+                        )
+                    })
+                    .collect()
+            }),
            extend_select: config.extend_select,
            ignore: config.ignore,
            line_length: config.line_length.unwrap_or(88),
--- a/src/snapshots/rufflintertests__C401_C401.py.snap
+++ b/src/snapshots/rufflintertests__C401_C401.py.snap
@@ -2,7 +2,7 @@
 source: src/linter.rs
 expression: checks
 ---
- kind: UnnecessaryGeneratorList
+- kind: UnnecessaryGeneratorSet
  location:
    row: 1
    column: 5
--- a/src/snapshots/rufflintertests__C402_C402.py.snap
+++ b/src/snapshots/rufflintertests__C402_C402.py.snap
@@ -2,7 +2,7 @@
 source: src/linter.rs
 expression: checks
 ---
- kind: UnnecessaryListComprehensionDict
+- kind: UnnecessaryGeneratorDict
  location:
    row: 1
    column: 5
--- a/src/snapshots/rufflintertests__C417_C417.py.snap
+++ b/src/snapshots/rufflintertests__C417_C417.py.snap
@@ -0,0 +1,77 @@
+---
+source: src/linter.rs
+expression: checks
+---
+- kind:
+    UnnecessaryMap: generator
+  location:
+    row: 2
+    column: 1
+  end_location:
+    row: 2
+    column: 27
+  fix: ~
+- kind:
+    UnnecessaryMap: generator
+  location:
+    row: 3
+    column: 1
+  end_location:
+    row: 3
+    column: 28
+  fix: ~
+- kind:
+    UnnecessaryMap: list
+  location:
+    row: 4
+    column: 1
+  end_location:
+    row: 4
+    column: 33
+  fix: ~
+- kind:
+    UnnecessaryMap: generator
+  location:
+    row: 4
+    column: 6
+  end_location:
+    row: 4
+    column: 32
+  fix: ~
+- kind:
+    UnnecessaryMap: set
+  location:
+    row: 5
+    column: 1
+  end_location:
+    row: 5
+    column: 37
+  fix: ~
+- kind:
+    UnnecessaryMap: generator
+  location:
+    row: 5
+    column: 5
+  end_location:
+    row: 5
+    column: 36
+  fix: ~
+- kind:
+    UnnecessaryMap: dict
+  location:
+    row: 6
+    column: 1
+  end_location:
+    row: 6
+    column: 37
+  fix: ~
+- kind:
+    UnnecessaryMap: generator
+  location:
+    row: 6
+    column: 6
+  end_location:
+    row: 6
+    column: 36
+  fix: ~
+
--- a/src/snapshots/rufflintertests__D201_D.py.snap
+++ b/src/snapshots/rufflintertests__D201_D.py.snap
@@ -10,7 +10,15 @@ expression: checks
  end_location:
    row: 132
    column: 25
-  fix: ~
+  fix:
+    content: ""
+    location:
+      row: 131
+      column: 1
+    end_location:
+      row: 132
+      column: 1
+    applied: false
 - kind:
    NoBlankLineBeforeFunction: 1
  location:
@@ -19,5 +27,13 @@ expression: checks
  end_location:
    row: 146
    column: 38
-  fix: ~
+  fix:
+    content: ""
+    location:
+      row: 145
+      column: 1
+    end_location:
+      row: 146
+      column: 1
+    applied: false

--- a/src/snapshots/rufflintertests__D202_D.py.snap
+++ b/src/snapshots/rufflintertests__D202_D.py.snap
@@ -2,6 +2,23 @@
 source: src/linter.rs
 expression: checks
 ---
+- kind:
+    NoBlankLineAfterFunction: 0
+  location:
+    row: 79
+    column: 5
+  end_location:
+    row: 79
+    column: 33
+  fix:
+    content: ""
+    location:
+      row: 81
+      column: 1
+    end_location:
+      row: 80
+      column: 1
+    applied: false
 - kind:
    NoBlankLineAfterFunction: 1
  location:
@@ -10,7 +27,15 @@ expression: checks
  end_location:
    row: 137
    column: 25
-  fix: ~
+  fix:
+    content: ""
+    location:
+      row: 138
+      column: 1
+    end_location:
+      row: 139
+      column: 1
+    applied: false
 - kind:
    NoBlankLineAfterFunction: 1
  location:
@@ -19,5 +44,30 @@ expression: checks
  end_location:
    row: 146
    column: 38
-  fix: ~
+  fix:
+    content: ""
+    location:
+      row: 147
+      column: 1
+    end_location:
+      row: 148
+      column: 1
+    applied: false
+- kind:
+    NoBlankLineAfterFunction: 0
+  location:
+    row: 453
+    column: 5
+  end_location:
+    row: 453
+    column: 24
+  fix:
+    content: ""
+    location:
+      row: 455
+      column: 1
+    end_location:
+      row: 454
+      column: 1
+    applied: false

--- a/src/snapshots/rufflintertests__D203_D.py.snap
+++ b/src/snapshots/rufflintertests__D203_D.py.snap
@@ -10,7 +10,15 @@ expression: checks
  end_location:
    row: 156
    column: 33
-  fix: ~
+  fix:
+    content: "\n"
+    location:
+      row: 156
+      column: 1
+    end_location:
+      row: 156
+      column: 1
+    applied: false
 - kind:
    OneBlankLineBeforeClass: 0
  location:
@@ -19,7 +27,15 @@ expression: checks
  end_location:
    row: 187
    column: 46
-  fix: ~
+  fix:
+    content: "\n"
+    location:
+      row: 187
+      column: 1
+    end_location:
+      row: 187
+      column: 1
+    applied: false
 - kind:
    OneBlankLineBeforeClass: 0
  location:
@@ -28,5 +44,13 @@ expression: checks
  end_location:
    row: 527
    column: 8
-  fix: ~
+  fix:
+    content: "\n"
+    location:
+      row: 521
+      column: 1
+    end_location:
+      row: 521
+      column: 1
+    applied: false

--- a/src/snapshots/rufflintertests__D204_D.py.snap
+++ b/src/snapshots/rufflintertests__D204_D.py.snap
@@ -10,7 +10,15 @@ expression: checks
  end_location:
    row: 176
    column: 25
-  fix: ~
+  fix:
+    content: "\n"
+    location:
+      row: 177
+      column: 1
+    end_location:
+      row: 177
+      column: 1
+    applied: false
 - kind:
    OneBlankLineAfterClass: 0
  location:
@@ -19,5 +27,13 @@ expression: checks
  end_location:
    row: 187
    column: 46
-  fix: ~
+  fix:
+    content: "\n"
+    location:
+      row: 188
+      column: 1
+    end_location:
+      row: 188
+      column: 1
+    applied: false

--- a/src/snapshots/rufflintertests__D205_D.py.snap
+++ b/src/snapshots/rufflintertests__D205_D.py.snap
@@ -9,7 +9,15 @@ expression: checks
  end_location:
    row: 198
    column: 8
-  fix: ~
+  fix:
+    content: "\n"
+    location:
+      row: 196
+      column: 1
+    end_location:
+      row: 196
+      column: 1
+    applied: false
 - kind: NoBlankLineAfterSummary
  location:
    row: 205
@@ -17,5 +25,13 @@ expression: checks
  end_location:
    row: 210
    column: 8
-  fix: ~
+  fix:
+    content: "\n"
+    location:
+      row: 206
+      column: 1
+    end_location:
+      row: 208
+      column: 1
+    applied: false

--- a/src/snapshots/rufflintertests__D206_D.py.snap
+++ b/src/snapshots/rufflintertests__D206_D.py.snap
@@ -0,0 +1,6 @@
+---
+source: src/linter.rs
+expression: checks
+---
+[]
+
--- a/src/snapshots/rufflintertests__D207_D.py.snap
+++ b/src/snapshots/rufflintertests__D207_D.py.snap
@@ -0,0 +1,29 @@
+---
+source: src/linter.rs
+expression: checks
+---
+- kind: NoUnderIndentation
+  location:
+    row: 225
+    column: 5
+  end_location:
+    row: 229
+    column: 8
+  fix: ~
+- kind: NoUnderIndentation
+  location:
+    row: 235
+    column: 5
+  end_location:
+    row: 239
+    column: 4
+  fix: ~
+- kind: NoUnderIndentation
+  location:
+    row: 433
+    column: 37
+  end_location:
+    row: 436
+    column: 8
+  fix: ~
+
--- a/src/snapshots/rufflintertests__D208_D.py.snap
+++ b/src/snapshots/rufflintertests__D208_D.py.snap
@@ -0,0 +1,29 @@
+---
+source: src/linter.rs
+expression: checks
+---
+- kind: NoOverIndentation
+  location:
+    row: 245
+    column: 5
+  end_location:
+    row: 249
+    column: 8
+  fix: ~
+- kind: NoOverIndentation
+  location:
+    row: 255
+    column: 5
+  end_location:
+    row: 259
+    column: 12
+  fix: ~
+- kind: NoOverIndentation
+  location:
+    row: 265
+    column: 5
+  end_location:
+    row: 269
+    column: 8
+  fix: ~
+
--- a/src/snapshots/rufflintertests__D209_D.py.snap
+++ b/src/snapshots/rufflintertests__D209_D.py.snap
@@ -9,5 +9,13 @@ expression: checks
  end_location:
    row: 278
    column: 20
-  fix: ~
+  fix:
+    content: "\n    "
+    location:
+      row: 278
+      column: 17
+    end_location:
+      row: 278
+      column: 17
+    applied: false

--- a/src/snapshots/rufflintertests__D210_D.py.snap
+++ b/src/snapshots/rufflintertests__D210_D.py.snap
@@ -9,7 +9,15 @@ expression: checks
  end_location:
    row: 283
    column: 34
-  fix: ~
+  fix:
+    content: Whitespace at the end.
+    location:
+      row: 283
+      column: 8
+    end_location:
+      row: 283
+      column: 31
+    applied: false
 - kind: NoSurroundingWhitespace
  location:
    row: 288
@@ -17,7 +25,15 @@ expression: checks
  end_location:
    row: 288
    column: 38
-  fix: ~
+  fix:
+    content: Whitespace at everywhere.
+    location:
+      row: 288
+      column: 8
+    end_location:
+      row: 288
+      column: 35
+    applied: false
 - kind: NoSurroundingWhitespace
  location:
    row: 294
@@ -25,5 +41,13 @@ expression: checks
  end_location:
    row: 297
    column: 8
-  fix: ~
+  fix:
+    content: Whitespace at the beginning.
+    location:
+      row: 294
+      column: 8
+    end_location:
+      row: 294
+      column: 37
+    applied: false

--- a/src/snapshots/rufflintertests__D211_D.py.snap
+++ b/src/snapshots/rufflintertests__D211_D.py.snap
@@ -10,7 +10,15 @@ expression: checks
  end_location:
    row: 165
    column: 30
-  fix: ~
+  fix:
+    content: ""
+    location:
+      row: 164
+      column: 1
+    end_location:
+      row: 165
+      column: 1
+    applied: false
 - kind:
    NoBlankLineBeforeClass: 1
  location:
@@ -19,5 +27,13 @@ expression: checks
  end_location:
    row: 176
    column: 25
-  fix: ~
+  fix:
+    content: ""
+    location:
+      row: 175
+      column: 1
+    end_location:
+      row: 176
+      column: 1
+    applied: false

--- a/src/snapshots/rufflintertests__D300_D.py.snap
+++ b/src/snapshots/rufflintertests__D300_D.py.snap
@@ -5,7 +5,7 @@ expression: checks
 - kind: UsesTripleQuotes
  location:
    row: 302
-    column: 6
+    column: 5
  end_location:
    row: 302
    column: 20
@@ -13,7 +13,7 @@ expression: checks
 - kind: UsesTripleQuotes
  location:
    row: 307
-    column: 6
+    column: 5
  end_location:
    row: 307
    column: 20
@@ -21,7 +21,7 @@ expression: checks
 - kind: UsesTripleQuotes
  location:
    row: 312
-    column: 6
+    column: 5
  end_location:
    row: 312
    column: 16
@@ -29,7 +29,7 @@ expression: checks
 - kind: UsesTripleQuotes
  location:
    row: 317
-    column: 6
+    column: 5
  end_location:
    row: 317
    column: 16
@@ -37,7 +37,7 @@ expression: checks
 - kind: UsesTripleQuotes
  location:
    row: 323
-    column: 6
+    column: 5
  end_location:
    row: 323
    column: 17
--- a/src/snapshots/rufflintertests__D407_sections.py.snap
+++ b/src/snapshots/rufflintertests__D407_sections.py.snap
@@ -47,4 +47,94 @@ expression: checks
    row: 262
    column: 8
  fix: ~
+- kind:
+    DashedUnderlineAfterSection: Args
+  location:
+    row: 269
+    column: 5
+  end_location:
+    row: 274
+    column: 8
+  fix: ~
+- kind:
+    DashedUnderlineAfterSection: Args
+  location:
+    row: 284
+    column: 9
+  end_location:
+    row: 292
+    column: 12
+  fix: ~
+- kind:
+    DashedUnderlineAfterSection: Args
+  location:
+    row: 301
+    column: 5
+  end_location:
+    row: 306
+    column: 8
+  fix: ~
+- kind:
+    DashedUnderlineAfterSection: Args
+  location:
+    row: 313
+    column: 9
+  end_location:
+    row: 319
+    column: 12
+  fix: ~
+- kind:
+    DashedUnderlineAfterSection: Args
+  location:
+    row: 325
+    column: 9
+  end_location:
+    row: 330
+    column: 12
+  fix: ~
+- kind:
+    DashedUnderlineAfterSection: Args
+  location:
+    row: 337
+    column: 9
+  end_location:
+    row: 343
+    column: 12
+  fix: ~
+- kind:
+    DashedUnderlineAfterSection: Args
+  location:
+    row: 350
+    column: 9
+  end_location:
+    row: 355
+    column: 12
+  fix: ~
+- kind:
+    DashedUnderlineAfterSection: Args
+  location:
+    row: 362
+    column: 9
+  end_location:
+    row: 367
+    column: 12
+  fix: ~
+- kind:
+    DashedUnderlineAfterSection: Args
+  location:
+    row: 371
+    column: 9
+  end_location:
+    row: 382
+    column: 12
+  fix: ~
+- kind:
+    DashedUnderlineAfterSection: Args
+  location:
+    row: 490
+    column: 9
+  end_location:
+    row: 497
+    column: 12
+  fix: ~

--- a/src/snapshots/rufflintertests__D410_sections.py.snap
+++ b/src/snapshots/rufflintertests__D410_sections.py.snap
@@ -10,7 +10,15 @@ expression: checks
  end_location:
    row: 78
    column: 8
-  fix: ~
+  fix:
+    content: "\n"
+    location:
+      row: 71
+      column: 1
+    end_location:
+      row: 71
+      column: 1
+    applied: false
 - kind:
    BlankLineAfterSection: Returns
  location:
@@ -19,5 +27,13 @@ expression: checks
  end_location:
    row: 221
    column: 8
-  fix: ~
+  fix:
+    content: "\n"
+    location:
+      row: 218
+      column: 1
+    end_location:
+      row: 218
+      column: 1
+    applied: false

--- a/src/snapshots/rufflintertests__D416_D.py.snap
+++ b/src/snapshots/rufflintertests__D416_D.py.snap
@@ -0,0 +1,6 @@
+---
+source: src/linter.rs
+expression: checks
+---
+[]
+
--- a/src/snapshots/rufflintertests__D417_canonical_google_examples.py.snap
+++ b/src/snapshots/rufflintertests__D417_canonical_google_examples.py.snap
@@ -0,0 +1,6 @@
+---
+source: src/linter.rs
+expression: checks
+---
+[]
+
--- a/src/snapshots/rufflintertests__D417_sections.py.snap
+++ b/src/snapshots/rufflintertests__D417_sections.py.snap
@@ -2,6 +2,73 @@
 source: src/linter.rs
 expression: checks
 ---
+- kind:
+    DocumentAllArguments:
+      - y
+  location:
+    row: 283
+    column: 5
+  end_location:
+    row: 296
+    column: 1
+  fix: ~
+- kind:
+    DocumentAllArguments:
+      - y
+  location:
+    row: 300
+    column: 1
+  end_location:
+    row: 309
+    column: 1
+  fix: ~
+- kind:
+    DocumentAllArguments:
+      - test
+      - y
+      - z
+  location:
+    row: 324
+    column: 5
+  end_location:
+    row: 332
+    column: 5
+  fix: ~
+- kind:
+    DocumentAllArguments:
+      - test
+      - y
+      - z
+  location:
+    row: 336
+    column: 5
+  end_location:
+    row: 345
+    column: 5
+  fix: ~
+- kind:
+    DocumentAllArguments:
+      - a
+      - y
+      - z
+  location:
+    row: 349
+    column: 5
+  end_location:
+    row: 357
+    column: 5
+  fix: ~
+- kind:
+    DocumentAllArguments:
+      - a
+      - b
+  location:
+    row: 361
+    column: 5
+  end_location:
+    row: 369
+    column: 5
+  fix: ~
 - kind:
    DocumentAllArguments:
      - y
@@ -47,4 +114,14 @@ expression: checks
    row: 471
    column: 5
  fix: ~
+- kind:
+    DocumentAllArguments:
+      - y
+  location:
+    row: 489
+    column: 5
+  end_location:
+    row: 498
+    column: 1
+  fix: ~

--- a/src/snapshots/rufflintertests__F541_F541.py.snap
+++ b/src/snapshots/rufflintertests__F541_F541.py.snap
@@ -5,7 +5,7 @@ expression: checks
 - kind: FStringMissingPlaceholders
  location:
    row: 4
-    column: 7
+    column: 5
  end_location:
    row: 4
    column: 11
@@ -13,7 +13,7 @@ expression: checks
 - kind: FStringMissingPlaceholders
  location:
    row: 5
-    column: 7
+    column: 5
  end_location:
    row: 5
    column: 11
@@ -21,7 +21,7 @@ expression: checks
 - kind: FStringMissingPlaceholders
  location:
    row: 7
-    column: 7
+    column: 5
  end_location:
    row: 7
    column: 11
--- a/src/snapshots/rufflintertests__F601_F601.py.snap
+++ b/src/snapshots/rufflintertests__F601_F601.py.snap
@@ -5,7 +5,7 @@ expression: checks
 - kind: MultiValueRepeatedKeyLiteral
  location:
    row: 3
-    column: 6
+    column: 5
  end_location:
    row: 3
    column: 8
@@ -21,7 +21,7 @@ expression: checks
 - kind: MultiValueRepeatedKeyLiteral
  location:
    row: 11
-    column: 7
+    column: 5
  end_location:
    row: 11
    column: 11
--- a/src/snapshots/rufflintertests__F722_F722.py.snap
+++ b/src/snapshots/rufflintertests__F722_F722.py.snap
@@ -6,9 +6,9 @@ expression: checks
    ForwardAnnotationSyntaxError: ///
  location:
    row: 9
-    column: 13
+    column: 12
  end_location:
    row: 9
-    column: 16
+    column: 17
  fix: ~

--- a/src/snapshots/rufflintertests__F821_F821.py.snap
+++ b/src/snapshots/rufflintertests__F821_F821.py.snap
@@ -42,10 +42,10 @@ expression: checks
    UndefinedName: Bar
  location:
    row: 58
-    column: 5
+    column: 4
  end_location:
    row: 58
-    column: 8
+    column: 9
  fix: ~
 - kind:
    UndefinedName: TOMATO
@@ -60,7 +60,7 @@ expression: checks
    UndefinedName: B
  location:
    row: 87
-    column: 7
+    column: 5
  end_location:
    row: 87
    column: 11
@@ -69,7 +69,7 @@ expression: checks
    UndefinedName: B
  location:
    row: 89
-    column: 7
+    column: 5
  end_location:
    row: 89
    column: 9
@@ -78,27 +78,27 @@ expression: checks
    UndefinedName: PEP593Test123
  location:
    row: 114
-    column: 10
+    column: 9
  end_location:
    row: 114
-    column: 23
+    column: 24
  fix: ~
 - kind:
    UndefinedName: foo
  location:
    row: 122
-    column: 15
+    column: 14
  end_location:
    row: 122
-    column: 18
+    column: 19
  fix: ~
 - kind:
    UndefinedName: bar
  location:
    row: 122
-    column: 22
+    column: 21
  end_location:
    row: 122
-    column: 25
+    column: 26
  fix: ~

--- a/src/snapshots/rufflintertests__N801_N801.py.snap
+++ b/src/snapshots/rufflintertests__N801_N801.py.snap
@@ -0,0 +1,50 @@
+---
+source: src/linter.rs
+expression: checks
+---
+- kind:
+    InvalidClassName: bad
+  location:
+    row: 1
+    column: 1
+  end_location:
+    row: 5
+    column: 1
+  fix: ~
+- kind:
+    InvalidClassName: _bad
+  location:
+    row: 5
+    column: 1
+  end_location:
+    row: 9
+    column: 1
+  fix: ~
+- kind:
+    InvalidClassName: bad_class
+  location:
+    row: 9
+    column: 1
+  end_location:
+    row: 13
+    column: 1
+  fix: ~
+- kind:
+    InvalidClassName: Bad_Class
+  location:
+    row: 13
+    column: 1
+  end_location:
+    row: 17
+    column: 1
+  fix: ~
+- kind:
+    InvalidClassName: BAD_CLASS
+  location:
+    row: 17
+    column: 1
+  end_location:
+    row: 21
+    column: 1
+  fix: ~
+
--- a/src/snapshots/rufflintertests__N802_N802.py.snap
+++ b/src/snapshots/rufflintertests__N802_N802.py.snap
@@ -0,0 +1,41 @@
+---
+source: src/linter.rs
+expression: checks
+---
+- kind:
+    InvalidFunctionName: Bad
+  location:
+    row: 1
+    column: 1
+  end_location:
+    row: 5
+    column: 1
+  fix: ~
+- kind:
+    InvalidFunctionName: _Bad
+  location:
+    row: 5
+    column: 1
+  end_location:
+    row: 9
+    column: 1
+  fix: ~
+- kind:
+    InvalidFunctionName: BAD
+  location:
+    row: 9
+    column: 1
+  end_location:
+    row: 13
+    column: 1
+  fix: ~
+- kind:
+    InvalidFunctionName: BAD_FUNC
+  location:
+    row: 13
+    column: 1
+  end_location:
+    row: 17
+    column: 1
+  fix: ~
+
--- a/src/snapshots/rufflintertests__N803_N803.py.snap
+++ b/src/snapshots/rufflintertests__N803_N803.py.snap
@@ -0,0 +1,23 @@
+---
+source: src/linter.rs
+expression: checks
+---
+- kind:
+    InvalidArgumentName: A
+  location:
+    row: 1
+    column: 13
+  end_location:
+    row: 1
+    column: 14
+  fix: ~
+- kind:
+    InvalidArgumentName: A
+  location:
+    row: 6
+    column: 25
+  end_location:
+    row: 6
+    column: 26
+  fix: ~
+
--- a/src/snapshots/rufflintertests__N804_N804.py.snap
+++ b/src/snapshots/rufflintertests__N804_N804.py.snap
@@ -0,0 +1,13 @@
+---
+source: src/linter.rs
+expression: checks
+---
+- kind: InvalidFirstArgumentNameForClassMethod
+  location:
+    row: 3
+    column: 26
+  end_location:
+    row: 3
+    column: 30
+  fix: ~
+
--- a/src/snapshots/rufflintertests__N805_N805.py.snap
+++ b/src/snapshots/rufflintertests__N805_N805.py.snap
@@ -0,0 +1,21 @@
+---
+source: src/linter.rs
+expression: checks
+---
+- kind: InvalidFirstArgumentNameForMethod
+  location:
+    row: 5
+    column: 20
+  end_location:
+    row: 5
+    column: 24
+  fix: ~
+- kind: InvalidFirstArgumentNameForMethod
+  location:
+    row: 10
+    column: 30
+  end_location:
+    row: 10
+    column: 34
+  fix: ~
+
--- a/src/snapshots/rufflintertests__U007_U007.py.snap
+++ b/src/snapshots/rufflintertests__U007_U007.py.snap
@@ -85,49 +85,49 @@ expression: checks
 - kind: UsePEP604Annotation
  location:
    row: 32
-    column: 11
+    column: 10
  end_location:
    row: 32
-    column: 47
+    column: 48
  fix:
    content: "str | int | Union[float, bytes]"
    location:
      row: 32
-      column: 11
+      column: 10
    end_location:
      row: 32
-      column: 47
+      column: 48
    applied: false
 - kind: UsePEP604Annotation
  location:
    row: 32
-    column: 11
+    column: 10
  end_location:
    row: 32
-    column: 47
+    column: 48
  fix:
    content: float | bytes
    location:
      row: 32
-      column: 11
+      column: 10
    end_location:
      row: 32
-      column: 47
+      column: 48
    applied: false
 - kind: UsePEP604Annotation
  location:
    row: 39
-    column: 11
+    column: 10
  end_location:
    row: 39
-    column: 33
+    column: 34
  fix:
    content: str | int
    location:
      row: 39
-      column: 11
+      column: 10
    end_location:
      row: 39
-      column: 33
+      column: 34
    applied: false

--- a/src/visibility.rs
+++ b/src/visibility.rs
@@ -5,7 +5,7 @@ use std::path::Path;
 use rustpython_ast::{Stmt, StmtKind};

 use crate::ast::helpers::match_name_or_attr;
-use crate::docstrings::types::Documentable;
+use crate::docstrings::definition::Documentable;

 #[derive(Debug, Clone)]
 pub enum Modifier {
Author	SHA1	Message	Date
Charlie Marsh	cf0d198365	Bump version to 0.0.79	2022-10-16 21:39:01 -04:00
Charlie Marsh	08b14ed77e	Remove leading 'or' from fixable match	2022-10-16 21:38:22 -04:00
Charlie Marsh	6ee3075867	Bump version to 0.0.78	2022-10-16 21:28:25 -04:00
Charlie Marsh	cc8a945cbf	Tweak messages for flake8-comprehensions rules (#444 )	2022-10-16 21:27:13 -04:00
Charlie Marsh	1a1922b3fc	Re-add the fix icon to README.md (#443 )	2022-10-16 21:21:30 -04:00
Charlie Marsh	48bd766298	Implement autofixes for more docstring rules (#442 )	2022-10-16 21:16:57 -04:00
Charlie Marsh	1ece3873cd	Implement autofix for newline-related docstring rules (#441 )	2022-10-16 19:40:38 -04:00
Charlie Marsh	472d902486	Rename docstring_plugins.rs to plugins.rs	2022-10-16 18:39:08 -04:00
Charlie Marsh	4ac6a18d40	Remove some Vec arguments	2022-10-16 18:17:10 -04:00
Charlie Marsh	8a47ea91ba	Use CheckCategory to drive default rules	2022-10-16 18:07:03 -04:00
Charlie Marsh	bd4394aa89	Capitalize pep8-naming messages	2022-10-16 17:58:26 -04:00
Charlie Marsh	56f69ce71e	Bump version to 0.0.77	2022-10-16 13:43:52 -04:00
Charlie Marsh	248a6cd50b	Remove offsets hacks for docstring parsing logic (#440 )	2022-10-16 13:43:30 -04:00
Charlie Marsh	d9e659d817	Revert "Remove trailing colon from messages" This reverts commit `77e5564f4b`.	2022-10-16 12:35:40 -04:00
Charlie Marsh	77e5564f4b	Remove trailing colon from messages	2022-10-16 12:09:46 -04:00
Charlie Marsh	e79766d5ec	Use backticks for pep8-naming messages	2022-10-16 12:09:07 -04:00
Harutaka Kawamura	c55fd76743	Implement N801 ~ N805 (#439 )	2022-10-16 11:58:39 -04:00
Charlie Marsh	e2aedc5ba8	Bump version to 0.0.76	2022-10-15 17:22:12 -04:00
Charlie Marsh	1b2d085460	Mark W292 as a non-AST check	2022-10-15 17:21:52 -04:00
Charlie Marsh	cb138526b1	Add a note on pydocstyle	2022-10-15 17:05:18 -04:00
Charlie Marsh	8eac270d8f	Add an FAQ	2022-10-15 16:52:20 -04:00
Charlie Marsh	6e19fd20bb	Add table of contents	2022-10-15 16:37:52 -04:00
Charlie Marsh	10868445f5	Use H3 for rules sections	2022-10-15 16:33:26 -04:00
Charlie Marsh	e3ecf21287	Break rules table into sections (#437 )	2022-10-15 16:29:08 -04:00
Charlie Marsh	fd849e112e	Remove checkmark from rule table (#436 )	2022-10-15 11:28:32 -04:00
Harutaka Kawamura	af27471c77	Fix C401 and C402 (#435 )	2022-10-15 09:16:43 -04:00
konstin	bb466bc8d3	Add initial wasm32-wasi support (#416 )	2022-10-14 20:58:18 -04:00
Charlie Marsh	7741a713e2	Avoid checking for updates when executing via stdin (#433 )	2022-10-14 20:57:40 -04:00
Charlie Marsh	3ab1cfc6f8	Make some improvements to the README	2022-10-14 17:30:40 -04:00
Charlie Marsh	e73f13473d	Add a .flake8 file for benchmarking	2022-10-14 17:05:24 -04:00
Charlie Marsh	3e8ef5b40f	Bump version to 0.0.75	2022-10-14 14:42:57 -04:00
Charlie Marsh	c59610906c	Optimize imports	2022-10-14 14:42:48 -04:00
Charlie Marsh	2353a52be8	Nest if	2022-10-14 14:36:45 -04:00
Charlie Marsh	bbffdd57ff	Handle multi-byte chars in SourceCodeLocator (#431 )	2022-10-14 14:29:18 -04:00
Charlie Marsh	3c15c578a7	Implement D206, D207, and D208 (#429 )	2022-10-14 13:26:36 -04:00
Charlie Marsh	6a8e31b2ff	Bump version to 0.0.74	2022-10-14 12:36:44 -04:00
Charlie Marsh	6407fd5a33	Re-arrange some docstring modules (#428 )	2022-10-14 12:34:35 -04:00
Harutaka Kawamura	b64040cbb2	Implement C417 (#426 )	2022-10-14 12:34:00 -04:00
Charlie Marsh	952a0eb4e3	Implement checks for Google-style docstrings (#427 )	2022-10-14 11:53:29 -04:00