Revert "Bump version to 0.0.222"

This reverts commit 852aab5758.
Bump version to 0.0.222
2023-01-13 23:56:29 -05:00 · 2023-01-13 23:50:08 -05:00 · 2023-01-13 23:46:32 -05:00 · 2023-01-13 23:33:15 -05:00 · 2023-01-13 23:26:34 -05:00 · 2023-01-13 23:20:20 -05:00
452 changed files with 15961 additions and 11229 deletions
--- a/.github/workflows/ci.yaml
+++ b/.github/workflows/ci.yaml
@@ -26,21 +26,9 @@ jobs:
          profile: minimal
          toolchain: nightly-2022-11-01
          override: true
-          components: rustfmt
-      - uses: actions/cache@v3
-        env:
-          cache-name: cache-cargo
-        with:
-          path: |
-            ~/.cargo/registry
-            ~/.cargo/git
-          key: ${{ runner.os }}-build-${{ env.cache-name }}-${{ hashFiles('**/Cargo.lock') }}
-          restore-keys: |
-            ${{ runner.os }}-build-${{ env.cache-name }}-
-            ${{ runner.os }}-build-
-            ${{ runner.os }}-
-      - run: cargo build --all --release
-      - run: ./target/release/ruff_dev generate-all
+      - uses: Swatinem/rust-cache@v1
+      - run: cargo build --all
+      - run: ./target/debug/ruff_dev generate-all
      - run: git diff --quiet README.md || echo "::error file=README.md::This file is outdated. Run 'cargo +nightly dev generate-all'."
      - run: git diff --quiet ruff.schema.json || echo "::error file=ruff.schema.json::This file is outdated. Run 'cargo +nightly dev generate-all'."
      - run: git diff --exit-code -- README.md ruff.schema.json
@@ -56,18 +44,6 @@ jobs:
          toolchain: nightly-2022-11-01
          override: true
          components: rustfmt
-      - uses: actions/cache@v3
-        env:
-          cache-name: cache-cargo
-        with:
-          path: |
-            ~/.cargo/registry
-            ~/.cargo/git
-          key: ${{ runner.os }}-build-${{ env.cache-name }}-${{ hashFiles('**/Cargo.lock') }}
-          restore-keys: |
-            ${{ runner.os }}-build-${{ env.cache-name }}-
-            ${{ runner.os }}-build-
-            ${{ runner.os }}-
      - run: cargo fmt --all --check

  cargo_clippy:
@@ -82,20 +58,9 @@ jobs:
          override: true
          components: clippy
          target: wasm32-unknown-unknown
-      - uses: actions/cache@v3
-        env:
-          cache-name: cache-cargo
-        with:
-          path: |
-            ~/.cargo/registry
-            ~/.cargo/git
-          key: ${{ runner.os }}-build-${{ env.cache-name }}-${{ hashFiles('**/Cargo.lock') }}
-          restore-keys: |
-            ${{ runner.os }}-build-${{ env.cache-name }}-
-            ${{ runner.os }}-build-
-            ${{ runner.os }}-
+      - uses: Swatinem/rust-cache@v1
      - run: cargo clippy --workspace --all-targets --all-features -- -D warnings -W clippy::pedantic
-      - run: cargo clippy --workspace --target wasm32-unknown-unknown --all-features -- -D warnings -W clippy::pedantic
+      - run: cargo clippy -p ruff --target wasm32-unknown-unknown --all-features -- -D warnings -W clippy::pedantic

  cargo-test:
    name: "cargo test"
@@ -107,25 +72,14 @@ jobs:
          profile: minimal
          toolchain: nightly-2022-11-01
          override: true
-      - uses: actions/cache@v3
-        env:
-          cache-name: cache-cargo
-        with:
-          path: |
-            ~/.cargo/registry
-            ~/.cargo/git
-          key: ${{ runner.os }}-build-${{ env.cache-name }}-${{ hashFiles('**/Cargo.lock') }}
-          restore-keys: |
-            ${{ runner.os }}-build-${{ env.cache-name }}-
-            ${{ runner.os }}-build-
-            ${{ runner.os }}-
+      - uses: Swatinem/rust-cache@v1
      - run: cargo install cargo-insta
      - run: pip install black[d]==22.12.0
      - name: Run tests
        run: |
          cargo insta test --all --delete-unreferenced-snapshots
          git diff --exit-code
-      - run: cargo test --package ruff --test black_compatibility_test -- --ignored
+      - run: cargo test --package ruff_cli --test black_compatibility_test -- --ignored

 # TODO(charlie): Re-enable the `wasm-pack` tests.
 # See: https://github.com/charliermarsh/ruff/issues/1425
@@ -167,22 +121,11 @@ jobs:
          profile: minimal
          toolchain: nightly-2022-11-01
          override: true
+      - uses: Swatinem/rust-cache@v1
      - uses: actions/setup-python@v4
        with:
          python-version: "3.11"
      - run: pip install maturin
-      - uses: actions/cache@v3
-        env:
-          cache-name: cache-cargo
-        with:
-          path: |
-            ~/.cargo/registry
-            ~/.cargo/git
-          key: ${{ runner.os }}-build-${{ env.cache-name }}-${{ hashFiles('**/Cargo.lock') }}
-          restore-keys: |
-            ${{ runner.os }}-build-${{ env.cache-name }}-
-            ${{ runner.os }}-build-
-            ${{ runner.os }}-
      - run: maturin build -b bin

  typos:
--- a/.github/workflows/playground.yaml
+++ b/.github/workflows/playground.yaml
@@ -31,7 +31,7 @@ jobs:
      - uses: jetli/wasm-pack-action@v0.4.0
      - uses: jetli/wasm-bindgen-action@v0.2.0
      - name: "Run wasm-pack"
-        run: wasm-pack build --target web --out-dir playground/src/pkg
+        run: wasm-pack build --target web --out-dir playground/src/pkg . -- -p ruff
      - name: "Install Node dependencies"
        run: npm ci
        working-directory: playground
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -1,6 +1,6 @@
 repos:
  - repo: https://github.com/charliermarsh/ruff-pre-commit
-    rev: v0.0.215
+    rev: v0.0.221
    hooks:
      - id: ruff

--- a/.github/CODE_OF_CONDUCT.md
+++ b/.github/CODE_OF_CONDUCT.md
--- a/.github/CONTRIBUTING.md
+++ b/.github/CONTRIBUTING.md
@@ -56,9 +56,9 @@ prior to merging.

 There are four phases to adding a new lint rule:

-1. Define the violation in `src/violations.rs` (e.g., `ModuleImportNotAtTopOfFile`).
-2. Map the violation to a code in `src/registry.rs` (e.g., `E402`).
-3. Define the _logic_ for triggering the violation in `src/checkers/ast.rs` (for AST-based checks),
+1. Define the violation struct in `src/violations.rs` (e.g., `ModuleImportNotAtTopOfFile`).
+2. Map the violation struct to a rule code in `src/registry.rs` (e.g., `E402`).
+3. Define the logic for triggering the violation in `src/checkers/ast.rs` (for AST-based checks),
   `src/checkers/tokens.rs` (for token-based checks), or `src/checkers/lines.rs` (for text-based checks).
 4. Add a test fixture.
 5. Update the generated files (documentation and generated code).
@@ -74,15 +74,16 @@ collecting diagnostics as it goes.
 If you need to inspect the AST, you can run `cargo +nightly dev print-ast` with a Python file. Grep
 for the `Check::new` invocations to understand how other, similar rules are implemented.

-To add a test fixture, create a file under `resources/test/fixtures/[plugin-name]`, named to match
-the code you defined earlier (e.g., `E402.py`). This file should contain a variety of
-violations and non-violations designed to evaluate and demonstrate the behavior of your lint rule.
+To add a test fixture, create a file under `resources/test/fixtures/[origin]`, named to match
+the code you defined earlier (e.g., `resources/test/fixtures/pycodestyle/E402.py`). This file should
+contain a variety of violations and non-violations designed to evaluate and demonstrate the behavior
+of your lint rule.

 Run `cargo +nightly dev generate-all` to generate the code for your new fixture. Then run Ruff
 locally with (e.g.) `cargo run resources/test/fixtures/pycodestyle/E402.py --no-cache --select E402`.

 Once you're satisfied with the output, codify the behavior as a snapshot test by adding a new
-`test_case` macro in the relevant `src/[plugin-name]/mod.rs` file. Then, run `cargo test --all`.
+`test_case` macro in the relevant `src/[origin]/mod.rs` file. Then, run `cargo test --all`.
 Your test will fail, but you'll be prompted to follow-up with `cargo insta review`. Accept the
 generated snapshot, then commit the snapshot file alongside the rest of your changes.

--- a/Cargo.lock
+++ b/Cargo.lock
@@ -735,10 +735,11 @@ checksum = "0ce7134b9999ecaf8bcd65542e436736ef32ddca1b3e06094cb6ec5755203b80"

 [[package]]
 name = "flake8-to-ruff"
-version = "0.0.215-dev.0"
+version = "0.0.221-dev.0"
 dependencies = [
 "anyhow",
 "clap 4.0.32",
+ "colored",
 "configparser",
 "once_cell",
 "regex",
@@ -1873,27 +1874,19 @@ dependencies = [

 [[package]]
 name = "ruff"
-version = "0.0.215"
+version = "0.0.221"
 dependencies = [
- "annotate-snippets 0.9.1",
 "anyhow",
- "assert_cmd",
- "atty",
- "bincode",
 "bitflags",
- "cachedir",
 "cfg-if 1.0.0",
 "chrono",
 "clap 4.0.32",
- "clap_complete_command",
- "clearscreen",
 "colored",
 "console_error_panic_hook",
 "console_log",
 "criterion",
 "dirs 4.0.0",
 "fern",
- "filetime",
 "getrandom 0.2.8",
 "glob",
 "globset",
@@ -1905,13 +1898,10 @@ dependencies = [
 "log",
 "natord",
 "nohash-hasher",
- "notify",
 "num-bigint",
 "num-traits",
 "once_cell",
 "path-absolutize",
- "quick-junit",
- "rayon",
 "regex",
 "ropey",
 "ruff_macros",
@@ -1923,25 +1913,57 @@ dependencies = [
 "semver",
 "serde",
 "serde-wasm-bindgen",
- "serde_json",
 "shellexpand",
- "similar",
 "strum",
 "strum_macros",
 "test-case",
 "textwrap",
 "titlecase",
 "toml_edit",
- "update-informer",
- "ureq",
- "walkdir",
 "wasm-bindgen",
 "wasm-bindgen-test",
 ]

+[[package]]
+name = "ruff_cli"
+version = "0.0.221"
+dependencies = [
+ "annotate-snippets 0.9.1",
+ "anyhow",
+ "assert_cmd",
+ "atty",
+ "bincode",
+ "cachedir",
+ "chrono",
+ "clap 4.0.32",
+ "clap_complete_command",
+ "clearscreen",
+ "colored",
+ "filetime",
+ "glob",
+ "ignore",
+ "itertools",
+ "log",
+ "notify",
+ "path-absolutize",
+ "quick-junit",
+ "rayon",
+ "regex",
+ "ruff",
+ "rustc-hash",
+ "serde",
+ "serde_json",
+ "similar",
+ "strum",
+ "textwrap",
+ "update-informer",
+ "ureq",
+ "walkdir",
+]
+
 [[package]]
 name = "ruff_dev"
-version = "0.0.215"
+version = "0.0.221"
 dependencies = [
 "anyhow",
 "clap 4.0.32",
@@ -1949,6 +1971,7 @@ dependencies = [
 "libcst",
 "once_cell",
 "ruff",
+ "ruff_cli",
 "rustpython-ast",
 "rustpython-common",
 "rustpython-parser",
@@ -1961,7 +1984,7 @@ dependencies = [

 [[package]]
 name = "ruff_macros"
-version = "0.0.215"
+version = "0.0.221"
 dependencies = [
 "once_cell",
 "proc-macro2",
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -2,11 +2,13 @@
 members = [
  "flake8_to_ruff",
  "ruff_dev",
+  "ruff_cli",
 ]
+default-members = [".", "ruff_cli"]

 [package]
 name = "ruff"
-version = "0.0.215"
+version = "0.0.221"
 authors = ["Charlie Marsh <charlie.r.marsh@gmail.com>"]
 edition = "2021"
 rust-version = "1.65.0"
@@ -19,22 +21,17 @@ license = "MIT"
 [lib]
 name = "ruff"
 crate-type = ["cdylib", "rlib"]
+doctest = false

 [dependencies]
-annotate-snippets = { version = "0.9.1", features = ["color"] }
 anyhow = { version = "1.0.66" }
-atty = { version = "0.2.14" }
-bincode = { version = "1.3.3" }
 bitflags = { version = "1.3.2" }
-cachedir = { version = "0.3.0" }
 cfg-if = { version = "1.0.0" }
 chrono = { version = "0.4.21", default-features = false, features = ["clock"] }
 clap = { version = "4.0.1", features = ["derive", "env"] }
-clap_complete_command = { version = "0.4.0" }
 colored = { version = "2.0.0" }
 dirs = { version = "4.0.0" }
 fern = { version = "0.6.1" }
-filetime = { version = "0.2.17" }
 glob = { version = "0.3.0" }
 globset = { version = "0.4.9" }
 ignore = { version = "0.4.18" }
@@ -43,15 +40,13 @@ libcst = { git = "https://github.com/charliermarsh/LibCST", rev = "f2f0b7a487a87
 log = { version = "0.4.17" }
 natord = { version = "1.0.9" }
 nohash-hasher = { version = "0.2.0" }
-notify = { version = "5.0.0" }
 num-bigint = { version = "0.4.3" }
 num-traits = "0.2.15"
 once_cell = { version = "1.16.0" }
 path-absolutize = { version = "3.0.14", features = ["once_cell_cache", "use_unix_paths_on_wasm"] }
-quick-junit = { version = "0.3.2" }
 regex = { version = "1.6.0" }
 ropey = { version = "1.5.0", features = ["cr_lines", "simd"], default-features = false }
-ruff_macros = { version = "0.0.215", path = "ruff_macros" }
+ruff_macros = { version = "0.0.221", path = "ruff_macros" }
 rustc-hash = { version = "1.1.0" }
 rustpython-ast = { features = ["unparse"], git = "https://github.com/RustPython/RustPython.git", rev = "d532160333ffeb6dbeca2c2728c2391cd1e53b7f" }
 rustpython-common = { git = "https://github.com/RustPython/RustPython.git", rev = "d532160333ffeb6dbeca2c2728c2391cd1e53b7f" }
@@ -59,20 +54,12 @@ rustpython-parser = { features = ["lalrpop"], git = "https://github.com/RustPyth
 schemars = { version = "0.8.11" }
 semver = { version = "1.0.16" }
 serde = { version = "1.0.147", features = ["derive"] }
-serde_json = { version = "1.0.87" }
 shellexpand = { version = "3.0.0" }
-similar = { version = "2.2.1" }
 strum = { version = "0.24.1", features = ["strum_macros"] }
 strum_macros = { version = "0.24.3" }
 textwrap = { version = "0.16.0" }
 titlecase = { version = "2.2.1" }
 toml_edit = { version = "0.17.1", features = ["easy"] }
-walkdir = { version = "2.3.2" }
-
-[target.'cfg(not(target_family = "wasm"))'.dependencies]
-clearscreen = { version = "2.0.0" }
-rayon = { version = "1.5.3" }
-update-informer = { version = "0.6.0", default-features = false, features = ["pypi"], optional = true }

 # https://docs.rs/getrandom/0.2.7/getrandom/#webassembly-support
 # For (future) wasm-pack support
@@ -87,17 +74,11 @@ wasm-bindgen = { version = "0.2.83" }
 [dev-dependencies]
 insta = { version = "1.19.1", features = ["yaml"] }
 test-case = { version = "2.2.2" }
-ureq = { version = "2.5.0", features = [] }
 wasm-bindgen-test = { version = "0.3.33" }

 [target.'cfg(not(target_family = "wasm"))'.dev-dependencies]
-assert_cmd = { version = "2.0.4" }
 criterion = { version = "0.4.0" }

-[features]
-default = ["update-informer"]
-update-informer = ["dep:update-informer"]
-
 [profile.release]
 panic = "abort"
 lto = "thin"
--- a/README.md
+++ b/README.md
@@ -46,7 +46,9 @@ imports, and more.

 Ruff is extremely actively developed and used in major open-source projects like:

+- [pandas](https://github.com/pandas-dev/pandas)
 - [FastAPI](https://github.com/tiangolo/fastapi)
+- [Apache Airflow](https://github.com/apache/airflow)
 - [Bokeh](https://github.com/bokeh/bokeh)
 - [Zulip](https://github.com/zulip/zulip)
 - [Pydantic](https://github.com/pydantic/pydantic)
@@ -139,8 +141,6 @@ Ruff is available as [`ruff`](https://pypi.org/project/ruff/) on PyPI:
 pip install ruff
 ```

-[![Packaging status](https://repology.org/badge/vertical-allrepos/ruff-python-linter.svg?exclude_unsupported=1)](https://repology.org/project/ruff-python-linter/versions)
-
 For **macOS Homebrew** and **Linuxbrew** users, Ruff is also available as [`ruff`](https://formulae.brew.sh/formula/ruff) on Homebrew:

 ```shell
@@ -159,14 +159,16 @@ For **Arch Linux** users, Ruff is also available as [`ruff`](https://archlinux.o
 pacman -S ruff
 ```

+[![Packaging status](https://repology.org/badge/vertical-allrepos/ruff-python-linter.svg?exclude_unsupported=1)](https://repology.org/project/ruff-python-linter/versions)
+
 ### Usage

 To run Ruff, try any of the following:

 ```shell
-ruff path/to/code/to/check.py  # Run Ruff over `check.py`
-ruff path/to/code/             # Run Ruff over all files in `/path/to/code` (and any subdirectories)
-ruff path/to/code/*.py         # Run Ruff over all `.py` files in `/path/to/code`
+ruff path/to/code/to/lint.py  # Run Ruff over `lint.py`
+ruff path/to/code/            # Run Ruff over all files in `/path/to/code` (and any subdirectories)
+ruff path/to/code/*.py        # Run Ruff over all `.py` files in `/path/to/code`
 ```

 You can run Ruff in `--watch` mode to automatically re-run on-change:
@@ -180,7 +182,7 @@ Ruff also works with [pre-commit](https://pre-commit.com):
 ```yaml
 - repo: https://github.com/charliermarsh/ruff-pre-commit
  # Ruff version.
-  rev: 'v0.0.215'
+  rev: 'v0.0.221'
  hooks:
    - id: ruff
      # Respect `exclude` and `extend-exclude` settings.
@@ -237,9 +239,9 @@ target-version = "py310"
 max-complexity = 10
 ```

-As an example, the following would configure Ruff to: (1) avoid checking for line-length
-violations (`E501`); (2) never remove unused imports (`F401`); and (3) ignore import-at-top-of-file
-errors (`E402`) in `__init__.py` files:
+As an example, the following would configure Ruff to: (1) avoid enforcing line-length violations
+(`E501`); (2) never remove unused imports (`F401`); and (3) ignore import-at-top-of-file violations
+(`E402`) in `__init__.py` files:

 ```toml
 [tool.ruff]
@@ -269,16 +271,16 @@ select = ["E", "F", "Q"]
 docstring-quotes = "double"
 ```

-Ruff mirrors Flake8's error code system, in which each error code consists of a one-to-three letter
-prefix, followed by three digits (e.g., `F401`). The prefix indicates that "source" of the error
-code (e.g., `F` for Pyflakes, `E` for `pycodestyle`, `ANN` for `flake8-annotations`). The set of
-enabled errors is determined by the `select` and `ignore` options, which support both the full
-error code (e.g., `F401`) and the prefix (e.g., `F`).
+Ruff mirrors Flake8's rule code system, in which each rule code consists of a one-to-three letter
+prefix, followed by three digits (e.g., `F401`). The prefix indicates that "source" of the rule
+(e.g., `F` for Pyflakes, `E` for `pycodestyle`, `ANN` for `flake8-annotations`). The set of enabled
+rules is determined by the `select` and `ignore` options, which support both the full code (e.g.,
+`F401`) and the prefix (e.g., `F`).

-As a special-case, Ruff also supports the `ALL` error code, which enables all error codes. Note that
-some of the `pydocstyle` error codes are conflicting (e.g., `D203` and `D211`) as they represent
-alternative docstring formats. Enabling `ALL` without further configuration may result in suboptimal
-behavior, especially for the `pydocstyle` plugin.
+As a special-case, Ruff also supports the `ALL` code, which enables all rules. Note that some of the
+`pydocstyle` rules conflict (e.g., `D203` and `D211`) as they represent alternative docstring
+formats. Enabling `ALL` without further configuration may result in suboptimal behavior, especially
+for the `pydocstyle` plugin.

 As an alternative to `pyproject.toml`, Ruff will also respect a `ruff.toml` file, which implements
 an equivalent schema (though the `[tool.ruff]` hierarchy can be omitted). For example, the
@@ -326,43 +328,43 @@ Options:
  -v, --verbose
          Enable verbose logging
  -q, --quiet
-          Only log errors
+          Print lint violations, but nothing else
  -s, --silent
-          Disable all logging (but still exit with status code "1" upon detecting errors)
+          Disable all logging (but still exit with status code "1" upon detecting lint violations)
  -e, --exit-zero
-          Exit with status code "0", even upon detecting errors
+          Exit with status code "0", even upon detecting lint violations
  -w, --watch
          Run in watch mode by re-running whenever files change
      --fix
-          Attempt to automatically fix lint errors
+          Attempt to automatically fix lint violations
      --fix-only
-          Fix any fixable lint errors, but don't report on leftover violations. Implies `--fix`
+          Fix any fixable lint violations, but don't report on leftover violations. Implies `--fix`
      --diff
          Avoid writing any fixed files back; instead, output a diff for each changed file to stdout
  -n, --no-cache
          Disable cache reads
      --isolated
          Ignore all configuration files
-      --select <SELECT>
-          Comma-separated list of error codes to enable (or ALL, to enable all checks)
-      --extend-select <EXTEND_SELECT>
-          Like --select, but adds additional error codes on top of the selected ones
-      --ignore <IGNORE>
-          Comma-separated list of error codes to disable
-      --extend-ignore <EXTEND_IGNORE>
-          Like --ignore, but adds additional error codes on top of the ignored ones
-      --exclude <EXCLUDE>
-          List of paths, used to exclude files and/or directories from checks
-      --extend-exclude <EXTEND_EXCLUDE>
-          Like --exclude, but adds additional files and directories on top of the excluded ones
-      --fixable <FIXABLE>
-          List of error codes to treat as eligible for autofix. Only applicable when autofix itself is enabled (e.g., via `--fix`)
-      --unfixable <UNFIXABLE>
-          List of error codes to treat as ineligible for autofix. Only applicable when autofix itself is enabled (e.g., via `--fix`)
+      --select <RULE_CODE>
+          Comma-separated list of rule codes to enable (or ALL, to enable all rules)
+      --extend-select <RULE_CODE>
+          Like --select, but adds additional rule codes on top of the selected ones
+      --ignore <RULE_CODE>
+          Comma-separated list of rule codes to disable
+      --extend-ignore <RULE_CODE>
+          Like --ignore, but adds additional rule codes on top of the ignored ones
+      --exclude <FILE_PATTERN>
+          List of paths, used to omit files and/or directories from analysis
+      --extend-exclude <FILE_PATTERN>
+          Like --exclude, but adds additional files and directories on top of those already excluded
+      --fixable <RULE_CODE>
+          List of rule codes to treat as eligible for autofix. Only applicable when autofix itself is enabled (e.g., via `--fix`)
+      --unfixable <RULE_CODE>
+          List of rule codes to treat as ineligible for autofix. Only applicable when autofix itself is enabled (e.g., via `--fix`)
      --per-file-ignores <PER_FILE_IGNORES>
          List of mappings from file pattern to code to exclude
      --format <FORMAT>
-          Output serialization format for error messages [env: RUFF_FORMAT=] [possible values: text, json, junit, grouped, github, gitlab]
+          Output serialization format for violations [env: RUFF_FORMAT=] [possible values: text, json, junit, grouped, github, gitlab]
      --stdin-filename <STDIN_FILENAME>
          The name of the file when passing it through stdin
      --cache-dir <CACHE_DIR>
@@ -380,7 +382,7 @@ Options:
      --target-version <TARGET_VERSION>
          The minimum Python version that should be supported
      --line-length <LINE_LENGTH>
-          Set the line-length for length-associated checks and automatic formatting
+          Set the line-length for length-associated rules and automatic formatting
      --max-complexity <MAX_COMPLEXITY>
          Maximum McCabe complexity allowed for a given function
      --add-noqa
@@ -392,7 +394,7 @@ Options:
      --show-files
          See the files Ruff will be run against with the current settings
      --show-settings
-          See the settings Ruff will use to check a given Python file
+          See the settings Ruff will use to lint a given Python file
  -h, --help
          Print help information
  -V, --version
@@ -449,16 +451,16 @@ in each directory's `pyproject.toml` file.
 By default, Ruff will also skip any files that are omitted via `.ignore`, `.gitignore`,
 `.git/info/exclude`, and global `gitignore` files (see: [`respect-gitignore`](#respect-gitignore)).

-Files that are passed to `ruff` directly are always checked, regardless of the above criteria.
-For example, `ruff /path/to/excluded/file.py` will always check `file.py`.
+Files that are passed to `ruff` directly are always linted, regardless of the above criteria.
+For example, `ruff /path/to/excluded/file.py` will always lint `file.py`.

 ### Ignoring errors

-To omit a lint check entirely, add it to the "ignore" list via [`ignore`](#ignore) or
+To omit a lint rule entirely, add it to the "ignore" list via [`ignore`](#ignore) or
 [`extend-ignore`](#extend-ignore), either on the command-line or in your `pyproject.toml` file.

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

 ```python
 # Ignore F841.
@@ -467,7 +469,7 @@ x = 1  # noqa: F841
 # Ignore E741 and F841.
 i = 1  # noqa: E741, F841

-# Ignore _all_ errors.
+# Ignore _all_ violations.
 x = 1  # noqa
 ```

@@ -481,9 +483,9 @@ Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor i
 """  # noqa: E501
 ```

-To ignore all errors across an entire file, Ruff supports Flake8's `# flake8: noqa` directive (or,
-equivalently, `# ruff: noqa`). Adding either of those directives to any part of a file will disable
-error reporting for the entire file.
+To ignore all violations across an entire file, Ruff supports Flake8's `# flake8: noqa` directive
+(or, equivalently, `# ruff: noqa`). Adding either of those directives to any part of a file will
+disable enforcement across the entire file.

 For targeted exclusions across entire files (e.g., "Ignore all F841 violations in
 `/path/to/file.py`"), see the [`per-file-ignores`](#per-file-ignores) configuration setting.
@@ -502,8 +504,8 @@ for more.

 Ruff supports several workflows to aid in `noqa` management.

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

@@ -513,13 +515,13 @@ You can run `ruff /path/to/file.py --extend-select RUF100 --fix` to automaticall

 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.
+add `noqa` directives to all failing lines, with the appropriate rule codes.

 ## Supported Rules

 Regardless of the rule's origin, Ruff re-implements every rule in Rust as a first-party feature.

-By default, Ruff enables all `E` and `F` error codes, which correspond to those built-in to Flake8.
+By default, Ruff enables all `E` and `F` rule codes, which correspond to those built-in to Flake8.

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

@@ -597,6 +599,7 @@ For more, see [pycodestyle](https://pypi.org/project/pycodestyle/2.9.1/) on PyPI
 | E902 | IOError | IOError: `...` |  |
 | E999 | SyntaxError | SyntaxError: `...` |  |
 | W292 | NoNewLineAtEndOfFile | No newline at end of file | 🛠 |
+| W505 | DocLineTooLong | Doc line too long (89 > 88 characters) |  |
 | W605 | InvalidEscapeSequence | Invalid escape sequence: '\c' | 🛠 |

 ### mccabe (C90)
@@ -614,6 +617,7 @@ For more, see [isort](https://pypi.org/project/isort/5.10.1/) on PyPI.
 | Code | Name | Message | Fix |
 | ---- | ---- | ------- | --- |
 | I001 | UnsortedImports | Import block is un-sorted or un-formatted | 🛠 |
+| I002 | MissingRequiredImport | Missing required import: `from __future__ import ...` | 🛠 |

 ### pydocstyle (D)

@@ -701,6 +705,7 @@ For more, see [pyupgrade](https://pypi.org/project/pyupgrade/3.2.0/) on PyPI.
 | UP027 | RewriteListComprehension | Replace unpacked list comprehension with a generator expression | 🛠 |
 | UP028 | RewriteYieldFrom | Replace `yield` over `for` loop with `yield from` | 🛠 |
 | UP029 | UnnecessaryBuiltinImport | Unnecessary builtin import: `...` | 🛠 |
+| UP030 | FormatLiterals | Use implicit references for positional format fields | 🛠 |

 ### pep8-naming (N)

@@ -777,6 +782,9 @@ For more, see [flake8-bandit](https://pypi.org/project/flake8-bandit/4.1.1/) on
 | S324 | HashlibInsecureHashFunction | Probable use of insecure hash functions in `hashlib`: "..." |  |
 | S501 | RequestWithNoCertValidation | Probable use of `...` call with `verify=False` disabling SSL certificate checks |  |
 | S506 | UnsafeYAMLLoad | Probable use of unsafe `yaml.load`. Allows instantiation of arbitrary objects. Consider `yaml.safe_load`. |  |
+| S508 | SnmpInsecureVersion | The use of SNMPv1 and SNMPv2 is insecure. Use SNMPv3 if able. |  |
+| S509 | SnmpWeakCryptography | You should not use SNMPv3 without encryption. `noAuthNoPriv` & `authNoPriv` is insecure. |  |
+| S701 | Jinja2AutoescapeFalse | By default, jinja2 sets `autoescape` to `False`. Consider using `autoescape=True` or the `select_autoescape` function to mitigate XSS vulnerabilities. |  |

 ### flake8-blind-except (BLE)

@@ -935,8 +943,8 @@ For more, see [flake8-pytest-style](https://pypi.org/project/flake8-pytest-style
 | PT021 | FixtureFinalizerCallback | Use `yield` instead of `request.addfinalizer` |  |
 | PT022 | UselessYieldFixture | No teardown in fixture `...`, use `return` instead of `yield` | 🛠 |
 | PT023 | IncorrectMarkParenthesesStyle | Use `@pytest.mark....` over `@pytest.mark....()` | 🛠 |
-| PT024 | UnnecessaryAsyncioMarkOnFixture | `pytest.mark.asyncio` is unnecessary for fixtures |  |
-| PT025 | ErroneousUseFixturesOnFixture | `pytest.mark.usefixtures` has no effect on fixtures |  |
+| PT024 | UnnecessaryAsyncioMarkOnFixture | `pytest.mark.asyncio` is unnecessary for fixtures | 🛠 |
+| PT025 | ErroneousUseFixturesOnFixture | `pytest.mark.usefixtures` has no effect on fixtures | 🛠 |
 | PT026 | UseFixturesWithoutParameters | Useless `pytest.mark.usefixtures` without parameters | 🛠 |

 ### flake8-quotes (Q)
@@ -945,10 +953,10 @@ For more, see [flake8-quotes](https://pypi.org/project/flake8-quotes/3.3.1/) on

 | Code | Name | Message | Fix |
 | ---- | ---- | ------- | --- |
-| Q000 | BadQuotesInlineString | Single quotes found but double quotes preferred |  |
-| Q001 | BadQuotesMultilineString | Single quote multiline found but double quotes preferred |  |
-| Q002 | BadQuotesDocstring | Single quote docstring found but double quotes preferred |  |
-| Q003 | AvoidQuoteEscape | Change outer quotes to avoid escaping inner quotes |  |
+| Q000 | BadQuotesInlineString | Single quotes found but double quotes preferred | 🛠 |
+| Q001 | BadQuotesMultilineString | Single quote multiline found but double quotes preferred | 🛠 |
+| Q002 | BadQuotesDocstring | Single quote docstring found but double quotes preferred | 🛠 |
+| Q003 | AvoidQuoteEscape | Change outer quotes to avoid escaping inner quotes | 🛠 |

 ### flake8-return (RET)

@@ -971,6 +979,7 @@ For more, see [flake8-simplify](https://pypi.org/project/flake8-simplify/0.19.3/

 | Code | Name | Message | Fix |
 | ---- | ---- | ------- | --- |
+| SIM115 | OpenFileWithContextHandler | Use context handler for opening files |  |
 | SIM101 | DuplicateIsinstanceCall | Multiple `isinstance` calls for `...`, merge into a single call | 🛠 |
 | SIM102 | NestedIfStatements | Use a single `if` statement instead of nested `if` statements |  |
 | SIM103 | ReturnBoolConditionDirectly | Return the condition `...` directly | 🛠 |
@@ -980,6 +989,7 @@ For more, see [flake8-simplify](https://pypi.org/project/flake8-simplify/0.19.3/
 | SIM109 | CompareWithTuple | Use `value in (..., ...)` instead of `value == ... or value == ...` | 🛠 |
 | SIM110 | ConvertLoopToAny | Use `return any(x for x in y)` instead of `for` loop | 🛠 |
 | SIM111 | ConvertLoopToAll | Use `return all(x for x in y)` instead of `for` loop | 🛠 |
+| SIM112 | UseCapitalEnvironmentVariables | Use capitalized environment variable `...` instead of `...` | 🛠 |
 | SIM117 | MultipleWithStatements | Use a single `with` statement with multiple contexts instead of nested `with` statements |  |
 | SIM118 | KeyInDict | Use `key in dict` instead of `key in dict.keys()` | 🛠 |
 | SIM201 | NegateEqualOp | Use `left != right` instead of `not left == right` | 🛠 |
@@ -993,6 +1003,7 @@ For more, see [flake8-simplify](https://pypi.org/project/flake8-simplify/0.19.3/
 | SIM222 | OrTrue | Use `True` instead of `... or True` | 🛠 |
 | SIM223 | AndFalse | Use `False` instead of `... and False` | 🛠 |
 | SIM300 | YodaConditions | Yoda conditions are discouraged, use `left == right` instead | 🛠 |
+| SIM401 | DictGetWithDefault | Use `var = dict.get(key, "default")` instead of an `if` block | 🛠 |

 ### flake8-tidy-imports (TID)

@@ -1066,8 +1077,8 @@ For more, see [pygrep-hooks](https://github.com/pre-commit/pygrep-hooks) on GitH
 | ---- | ---- | ------- | --- |
 | PGH001 | NoEval | No builtin `eval()` allowed |  |
 | PGH002 | DeprecatedLogWarn | `warn` is deprecated in favor of `warning` |  |
-| PGH003 | BlanketTypeIgnore | Use specific error codes when ignoring type issues |  |
-| PGH004 | BlanketNOQA | Use specific error codes when using `noqa` |  |
+| PGH003 | BlanketTypeIgnore | Use specific rule codes when ignoring type issues |  |
+| PGH004 | BlanketNOQA | Use specific rule codes when using `noqa` |  |

 ### Pylint (PLC, PLE, PLR, PLW)

@@ -1083,8 +1094,10 @@ For more, see [Pylint](https://pypi.org/project/pylint/2.15.7/) on PyPI.
 | PLE1142 | AwaitOutsideAsync | `await` should be used within an async function |  |
 | PLR0206 | PropertyWithParameters | Cannot have defined parameters for properties |  |
 | PLR0402 | ConsiderUsingFromImport | Use `from ... import ...` in lieu of alias |  |
+| PLR0133 | ConstantComparison | Two constants compared in a comparison, consider replacing `0 == 0` |  |
 | PLR1701 | ConsiderMergingIsinstance | Merge these isinstance calls: `isinstance(..., (...))` |  |
 | PLR1722 | UseSysExit | Use `sys.exit()` instead of `exit` | 🛠 |
+| PLR2004 | MagicValueComparison | Magic number used in comparison, consider replacing magic with a constant variable |  |
 | PLW0120 | UselessElseOnLoop | Else clause on loop without a break statement, remove the else and de-indent all the code inside it |  |
 | PLW0602 | GlobalVariableNotAssigned | Using global for `...` but no assignment is done |  |

@@ -1243,6 +1256,18 @@ officially supported LSP server for Ruff.
 However, Ruff is also available as part of the [coc-pyright](https://github.com/fannheyward/coc-pyright)
 extension for `coc.nvim`.

+<details>
+<summary>With the <a href="https://github.com/dense-analysis/ale">ALE</a> plugin for (Neo)Vim.</summary>
+
+```vim
+let g:ale_linters = { "python": ["ruff"] }
+let g:ale_fixers = {
+\       "python": ["black", "ruff"],
+\}
+```
+
+</details>
+
 <details>
 <summary>Ruff can also be integrated via <a href="https://github.com/neovim/nvim-lspconfig/blob/master/doc/server_configurations.md#efm"><code>efm</code></a> in just a <a href="https://github.com/JafarAbdi/myconfigs/blob/6f0b6b2450e92ec8fc50422928cd22005b919110/efm-langserver/config.yaml#L14-L20">few lines</a>.</summary>
 <br>
@@ -1393,7 +1418,7 @@ natively, including:
 - [`pyupgrade`](https://pypi.org/project/pyupgrade/) ([#827](https://github.com/charliermarsh/ruff/issues/827))
 - [`yesqa`](https://github.com/asottile/yesqa)

-Note that, in some cases, Ruff uses different error code prefixes than would be found in the
+Note that, in some cases, Ruff uses different rule codes and prefixes than would be found in the
 originating Flake8 plugins. For example, Ruff uses `TID252` to represent the `I252` rule from
 `flake8-tidy-imports`. This helps minimize conflicts across plugins and allows any individual plugin
 to be toggled on or off with a single (e.g.) `--select TID`, as opposed to `--select I2` (to avoid
@@ -1407,7 +1432,7 @@ Beyond the rule set, Ruff suffers from the following limitations vis-à-vis Flak

 There are a few other minor incompatibilities between Ruff and the originating Flake8 plugins:

- Ruff doesn't implement the "opinionated" lint rules from `flake8-bugbear`.
+- Ruff doesn't implement all the "opinionated" lint rules from `flake8-bugbear`.
 - Depending on your project structure, Ruff and `isort` can differ in their detection of first-party
  code. (This is often solved by modifying the `src` property, e.g., to `src = ["src"]`, if your
  code is nested in a `src` directory.)
@@ -1418,9 +1443,9 @@ At time of writing, Pylint implements 409 total rules, while Ruff implements 224
 at least 60 overlap with the Pylint rule set. Subjectively, Pylint tends to implement more rules
 based on type inference (e.g., validating the number of arguments in a function call).

-Like Flake8, Pylint supports plugins (called "checkers"), while Ruff implements all checks natively.
+Like Flake8, Pylint supports plugins (called "checkers"), while Ruff implements all rules natively.

-Unlike Pylint, Ruff is capable of automatically fixing its own lint errors.
+Unlike Pylint, Ruff is capable of automatically fixing its own lint violations.

 Pylint parity is being tracked in [#689](https://github.com/charliermarsh/ruff/issues/689).

@@ -1533,7 +1558,7 @@ For example, if you're coming from `flake8-docstrings`, and your originating con
 `--docstring-convention=numpy`, you'd instead set `convention = "numpy"` in your `pyproject.toml`,
 as above.

-Alongside `convention`, you'll want to explicitly enable the `D` error code class, like so:
+Alongside `convention`, you'll want to explicitly enable the `D` rule code prefix, like so:

 ```toml
 [tool.ruff]
@@ -1739,6 +1764,24 @@ allowed-confusables = ["−", "ρ", "∗"]

 ---

+#### [`builtins`](#builtins)
+
+A list of builtins to treat as defined references, in addition to the
+system builtins.
+
+**Default value**: `[]`
+
+**Type**: `Vec<String>`
+
+**Example usage**:
+
+```toml
+[tool.ruff]
+builtins = ["_"]
+```
+
+---
+
 #### [`cache-dir`](#cache-dir)

 A path to the cache directory.
@@ -1768,7 +1811,7 @@ cache-dir = "~/.cache/ruff"
 #### [`dummy-variable-rgx`](#dummy-variable-rgx)

 A regular expression used to identify "dummy" variables, or those which
-should be ignored when evaluating (e.g.) unused-variable checks. The
+should be ignored when enforcing (e.g.) unused-variable rules. The
 default expression matches `_`, `__`, and `_var`, but not `_var_`.

 **Default value**: `"^(_+|(_+[a-zA-Z0-9_]*[a-zA-Z0-9]+?))$"`
@@ -1799,6 +1842,8 @@ Exclusions are based on globs, and can be either:
  `directory`). Note that these paths are relative to the project root
  (e.g., the directory containing your `pyproject.toml`).

+For more information on the glob syntax, refer to the [`globset` documentation](https://docs.rs/globset/latest/globset/#syntax).
+
 Note that you'll typically want to use
 [`extend-exclude`](#extend-exclude) to modify the excluded paths.

@@ -1846,6 +1891,18 @@ line-length = 100
 A list of file patterns to omit from linting, in addition to those
 specified by `exclude`.

+Exclusions are based on globs, and can be either:
+
+- Single-path patterns, like `.mypy_cache` (to exclude any directory
+  named `.mypy_cache` in the tree), `foo.py` (to exclude any file named
+  `foo.py`), or `foo_*.py` (to exclude any file matching `foo_*.py` ).
+- Relative patterns, like `directory/foo.py` (to exclude that specific
+  file) or `directory/*.py` (to exclude any Python files in
+  `directory`). Note that these paths are relative to the project root
+  (e.g., the directory containing your `pyproject.toml`).
+
+For more information on the glob syntax, refer to the [`globset` documentation](https://docs.rs/globset/latest/globset/#syntax).
+
 **Default value**: `[]`

 **Type**: `Vec<FilePattern>`
@@ -1862,18 +1919,24 @@ extend-exclude = ["tests", "src/bad.py"]

 #### [`extend-ignore`](#extend-ignore)

-A list of check code prefixes to ignore, in addition to those specified
-by `ignore`.
+A list of rule codes or prefixes to ignore, in addition to those
+specified by `ignore`.
+
+Note that `extend-ignore` is applied after resolving rules from
+`ignore`/`select` and a less specific rule in `extend-ignore`
+would overwrite a more specific rule in `select`. It is
+recommended to only use `extend-ignore` when extending a
+`pyproject.toml` file via `extend`.

 **Default value**: `[]`

-**Type**: `Vec<CheckCodePrefix>`
+**Type**: `Vec<RuleCodePrefix>`

 **Example usage**:

 ```toml
 [tool.ruff]
-# Skip unused variable checks (`F841`).
+# Skip unused variable rules (`F841`).
 extend-ignore = ["F841"]
 ```

@@ -1881,12 +1944,18 @@ extend-ignore = ["F841"]

 #### [`extend-select`](#extend-select)

-A list of check code prefixes to enable, in addition to those specified
-by `select`.
+A list of rule codes or prefixes to enable, in addition to those
+specified by `select`.
+
+Note that `extend-select` is applied after resolving rules from
+`ignore`/`select` and a less specific rule in `extend-select`
+would overwrite a more specific rule in `ignore`. It is
+recommended to only use `extend-select` when extending a
+`pyproject.toml` file via `extend`.

 **Default value**: `[]`

-**Type**: `Vec<CheckCodePrefix>`
+**Type**: `Vec<RuleCodePrefix>`

 **Example usage**:

@@ -1900,10 +1969,10 @@ extend-select = ["B", "Q"]

 #### [`external`](#external)

-A list of check codes that are unsupported by Ruff, but should be
+A list of rule codes that are unsupported by Ruff, but should be
 preserved when (e.g.) validating `# noqa` directives. Useful for
 retaining `# noqa` directives that cover plugins not yet implemented
-in Ruff.
+by Ruff.

 **Default value**: `[]`

@@ -1957,17 +2026,17 @@ fix-only = true

 #### [`fixable`](#fixable)

-A list of check code prefixes to consider autofix-able.
+A list of rule codes or prefixes to consider autofixable.

 **Default value**: `["A", "ANN", "ARG", "B", "BLE", "C", "D", "E", "ERA", "F", "FBT", "I", "ICN", "N", "PGH", "PLC", "PLE", "PLR", "PLW", "Q", "RET", "RUF", "S", "T", "TID", "UP", "W", "YTT"]`

-**Type**: `Vec<CheckCodePrefix>`
+**Type**: `Vec<RuleCodePrefix>`

 **Example usage**:

 ```toml
 [tool.ruff]
-# Only allow autofix behavior for `E` and `F` checks.
+# Only allow autofix behavior for `E` and `F` rules.
 fixable = ["E", "F"]
 ```

@@ -2023,23 +2092,23 @@ format = "grouped"

 #### [`ignore`](#ignore)

-A list of check code prefixes to ignore. Prefixes can specify exact
-checks (like `F841`), entire categories (like `F`), or anything in
+A list of rule codes or prefixes to ignore. Prefixes can specify exact
+rules (like `F841`), entire categories (like `F`), or anything in
 between.

-When breaking ties between enabled and disabled checks (via `select` and
+When breaking ties between enabled and disabled rules (via `select` and
 `ignore`, respectively), more specific prefixes override less
 specific prefixes.

 **Default value**: `[]`

-**Type**: `Vec<CheckCodePrefix>`
+**Type**: `Vec<RuleCodePrefix>`

 **Example usage**:

 ```toml
 [tool.ruff]
-# Skip unused variable checks (`F841`).
+# Skip unused variable rules (`F841`).
 ignore = ["F841"]
 ```

@@ -2087,12 +2156,12 @@ line-length = 120

 #### [`per-file-ignores`](#per-file-ignores)

-A list of mappings from file pattern to check code prefixes to exclude,
-when considering any matching files.
+A list of mappings from file pattern to rule codes or prefixes to
+exclude, when considering any matching files.

 **Default value**: `{}`

-**Type**: `HashMap<String, Vec<CheckCodePrefix>>`
+**Type**: `HashMap<String, Vec<RuleCodePrefix>>`

 **Example usage**:

@@ -2146,17 +2215,17 @@ respect_gitignore = false

 #### [`select`](#select)

-A list of check code prefixes to enable. Prefixes can specify exact
-checks (like `F841`), entire categories (like `F`), or anything in
+A list of rule codes or prefixes to enable. Prefixes can specify exact
+rules (like `F841`), entire categories (like `F`), or anything in
 between.

-When breaking ties between enabled and disabled checks (via `select` and
+When breaking ties between enabled and disabled rules (via `select` and
 `ignore`, respectively), more specific prefixes override less
 specific prefixes.

 **Default value**: `["E", "F"]`

-**Type**: `Vec<CheckCodePrefix>`
+**Type**: `Vec<RuleCodePrefix>`

 **Example usage**:

@@ -2170,8 +2239,8 @@ select = ["E", "F", "B", "Q"]

 #### [`show-source`](#show-source)

-Whether to show source code snippets when reporting lint error
-violations (overridden by the `--show-source` command-line flag).
+Whether to show source code snippets when reporting lint violations
+(overridden by the `--show-source` command-line flag).

 **Default value**: `false`

@@ -2254,7 +2323,7 @@ target-version = "py37"
 A list of task tags to recognize (e.g., "TODO", "FIXME", "XXX").

 Comments starting with these tags will be ignored by commented-out code
-detection (`ERA`), and skipped by line-length checks (`E501`) if
+detection (`ERA`), and skipped by line-length rules (`E501`) if
 `ignore-overlong-task-comments` is set to `true`.

 **Default value**: `["TODO", "FIXME", "XXX"]`
@@ -2270,13 +2339,37 @@ task-tags = ["HACK"]

 ---

-#### [`unfixable`](#unfixable)
+#### [`typing-modules`](#typing-modules)

-A list of check code prefixes to consider un-autofix-able.
+A list of modules whose imports should be treated equivalently to
+members of the `typing` module.
+
+This is useful for ensuring proper type annotation inference for
+projects that re-export `typing` and `typing_extensions` members
+from a compatibility module. If omitted, any members imported from
+modules apart from `typing` and `typing_extensions` will be treated
+as ordinary Python objects.

 **Default value**: `[]`

-**Type**: `Vec<CheckCodePrefix>`
+**Type**: `Vec<String>`
+
+**Example usage**:
+
+```toml
+[tool.ruff]
+typing-modules = ["airflow.typing_compat"]
+```
+
+---
+
+#### [`unfixable`](#unfixable)
+
+A list of rule codes or prefixes to consider non-autofix-able.
+
+**Default value**: `[]`
+
+**Type**: `Vec<RuleCodePrefix>`

 **Example usage**:

@@ -2293,7 +2386,7 @@ unfixable = ["F401"]
 Enable or disable automatic update checks (overridden by the
 `--update-check` and `--no-update-check` command-line flags).

-**Default value**: `true`
+**Default value**: `false`

 **Type**: `bool`

@@ -2301,7 +2394,7 @@ Enable or disable automatic update checks (overridden by the

 ```toml
 [tool.ruff]
-update-check = false
+update-check = true
 ```

 ---
@@ -2346,7 +2439,7 @@ mypy-init-return = true

 #### [`suppress-dummy-args`](#suppress-dummy-args)

-Whether to suppress `ANN000`-level errors for arguments matching the
+Whether to suppress `ANN000`-level violations for arguments matching the
 "dummy" variable regex (like `_`).

 **Default value**: `false`
@@ -2364,8 +2457,8 @@ suppress-dummy-args = true

 #### [`suppress-none-returning`](#suppress-none-returning)

-Whether to suppress `ANN200`-level errors for functions that meet either
-of the following criteria:
+Whether to suppress `ANN200`-level violations for functions that meet
+either of the following criteria:

 - Contain no `return` statement.
 - Explicit `return` statement(s) all return `None` (explicitly or
@@ -2426,7 +2519,7 @@ extend-hardcoded-tmp-directory = ["/foo/bar"]
 #### [`extend-immutable-calls`](#extend-immutable-calls)

 Additional callable functions to consider "immutable" when evaluating,
-e.g., `no-mutable-default-argument` checks (`B006`).
+e.g., the `no-mutable-default-argument` rule (`B006`).

 **Default value**: `[]`

@@ -2513,9 +2606,9 @@ will be added to the `aliases` mapping.

 Boolean flag specifying whether `@pytest.fixture()` without parameters
 should have parentheses. If the option is set to `true` (the
-default), `@pytest.fixture()` is valid and `@pytest.fixture` is an
-error. If set to `false`, `@pytest.fixture` is valid and
-`@pytest.fixture()` is an error.
+default), `@pytest.fixture()` is valid and `@pytest.fixture` is
+invalid. If set to `false`, `@pytest.fixture` is valid and
+`@pytest.fixture()` is invalid.

 **Default value**: `true`

@@ -2534,9 +2627,9 @@ fixture-parentheses = true

 Boolean flag specifying whether `@pytest.mark.foo()` without parameters
 should have parentheses. If the option is set to `true` (the
-default), `@pytest.mark.foo()` is valid and `@pytest.mark.foo` is an
-error. If set to `false`, `@pytest.fixture` is valid and
-`@pytest.mark.foo()` is an error.
+default), `@pytest.mark.foo()` is valid and `@pytest.mark.foo` is
+invalid. If set to `false`, `@pytest.fixture` is valid and
+`@pytest.mark.foo()` is invalid.

 **Default value**: `true`

@@ -2758,7 +2851,7 @@ ban-relative-imports = "all"
 #### [`banned-api`](#banned-api)

 Specific modules or module members that may not be imported or accessed.
-Note that this check is only meant to flag accidental uses,
+Note that this rule is only meant to flag accidental uses,
 and can be circumvented via `eval` or `importlib`.

 **Default value**: `{}`
@@ -2797,6 +2890,24 @@ ignore-variadic-names = true

 ### `isort`

+#### [`classes`](#classes)
+
+An override list of tokens to always recognize as a Class for
+`order-by-type` regardless of casing.
+
+**Default value**: `[]`
+
+**Type**: `Vec<String>`
+
+**Example usage**:
+
+```toml
+[tool.ruff.isort]
+classes = ["SVC"]
+```
+
+---
+
 #### [`combine-as-imports`](#combine-as-imports)

 Combines as imports on the same line. See isort's [`combine-as-imports`](https://pycqa.github.io/isort/docs/configuration/options.html#combine-as-imports)
@@ -2850,6 +2961,25 @@ force-single-line = true

 ---

+#### [`force-sort-within-sections`](#force-sort-within-sections)
+
+Don't sort straight-style imports (like `import sys`) before from-style
+imports (like `from itertools import groupby`). Instead, sort the
+imports by module, independent of import style.
+
+**Default value**: `false`
+
+**Type**: `bool`
+
+**Example usage**:
+
+```toml
+[tool.ruff.isort]
+force-sort-within-sections = true
+```
+
+---
+
 #### [`force-wrap-aliases`](#force-wrap-aliases)

 Force `import from` statements with multiple members and at least one
@@ -2937,6 +3067,47 @@ order-by-type = true

 ---

+#### [`relative-imports-order`](#relative-imports-order)
+
+Whether to place "closer" imports (fewer `.` characters, most local)
+before "further" imports (more `.` characters, least local), or vice
+versa.
+
+The default ("furthest-to-closest") is equivalent to isort's
+`reverse-relative` default (`reverse-relative = false`); setting
+this to "closest-to-furthest" is equivalent to isort's `reverse-relative
+= true`.
+
+**Default value**: `furthest-to-closest`
+
+**Type**: `RelatveImportsOrder`
+
+**Example usage**:
+
+```toml
+[tool.ruff.isort]
+relative-imports-order = "closest-to-furthest"
+```
+
+---
+
+#### [`required-imports`](#required-imports)
+
+Add the specified import line to all files.
+
+**Default value**: `[]`
+
+**Type**: `Vec<String>`
+
+**Example usage**:
+
+```toml
+[tool.ruff.isort]
+required-imports = ["from __future__ import annotations"]
+```
+
+---
+
 #### [`single-line-exclusions`](#single-line-exclusions)

 One or more modules to exclude from the single line rule.
@@ -3059,7 +3230,7 @@ staticmethod-decorators = ["staticmethod", "stcmthd"]

 #### [`ignore-overlong-task-comments`](#ignore-overlong-task-comments)

-Whether or not line-length checks (`E501`) should be triggered for
+Whether or not line-length violations (`E501`) should be triggered for
 comments starting with `task-tags` (by default: ["TODO", "FIXME",
 and "XXX"]).

@@ -3076,6 +3247,24 @@ ignore-overlong-task-comments = true

 ---

+#### [`max-doc-length`](#max-doc-length)
+
+The maximum line length to allow for line-length violations within
+documentation (`W505`), including standalone comments.
+
+**Default value**: `None`
+
+**Type**: `usize`
+
+**Example usage**:
+
+```toml
+[tool.ruff.pycodestyle]
+max-doc-length = 88
+```
+
+---
+
 ### `pydocstyle`

 #### [`convention`](#convention)
@@ -3130,4 +3319,4 @@ MIT
 ## Contributing

 Contributions are welcome and hugely appreciated. To get started, check out the
-[contributing guidelines](https://github.com/charliermarsh/ruff/blob/main/.github/CONTRIBUTING.md).
+[contributing guidelines](https://github.com/charliermarsh/ruff/blob/main/CONTRIBUTING.md).
--- a/flake8_to_ruff/Cargo.lock
+++ b/flake8_to_ruff/Cargo.lock
@@ -771,7 +771,7 @@ checksum = "0ce7134b9999ecaf8bcd65542e436736ef32ddca1b3e06094cb6ec5755203b80"

 [[package]]
 name = "flake8_to_ruff"
-version = "0.0.215"
+version = "0.0.221"
 dependencies = [
 "anyhow",
 "clap",
@@ -1975,7 +1975,7 @@ dependencies = [

 [[package]]
 name = "ruff"
-version = "0.0.215"
+version = "0.0.221"
 dependencies = [
 "anyhow",
 "bincode",
--- a/flake8_to_ruff/Cargo.toml
+++ b/flake8_to_ruff/Cargo.toml
@@ -1,14 +1,16 @@
 [package]
 name = "flake8-to-ruff"
-version = "0.0.215-dev.0"
+version = "0.0.221-dev.0"
 edition = "2021"

 [lib]
 name = "flake8_to_ruff"
+doctest = false

 [dependencies]
 anyhow = { version = "1.0.66" }
 clap = { version = "4.0.1", features = ["derive"] }
+colored = { version = "2.0.0" }
 configparser = { version = "3.0.2" }
 once_cell = { version = "1.16.0" }
 regex = { version = "1.6.0" }
--- a/flake8_to_ruff/README.md
+++ b/flake8_to_ruff/README.md
@@ -84,7 +84,7 @@ flake8-to-ruff path/to/.flake8 --plugin flake8-builtins --plugin flake8-quotes
 1. Ruff only supports a subset of the Flake configuration options. `flake8-to-ruff` will warn on and
   ignore unsupported options in the `.flake8` file (or equivalent). (Similarly, Ruff has a few
   configuration options that don't exist in Flake8.)
-2. Ruff will omit any error codes that are unimplemented or unsupported by Ruff, including error
+2. Ruff will omit any rule codes that are unimplemented or unsupported by Ruff, including rule
   codes from unsupported plugins. (See the [Ruff README](https://github.com/charliermarsh/ruff#user-content-how-does-ruff-compare-to-flake8)
   for the complete list of supported plugins.)

--- a/flake8_to_ruff/examples/jupyterhub.ini
+++ b/flake8_to_ruff/examples/jupyterhub.ini
@@ -0,0 +1,19 @@
+[flake8]
+# Ignore style and complexity
+# E: style errors
+# W: style warnings
+# C: complexity
+# D: docstring warnings (unused pydocstyle extension)
+# F841: local variable assigned but never used
+ignore = E, C, W, D, F841
+builtins = c, get_config
+exclude =
+    .cache,
+    .github,
+    docs,
+    jupyterhub/alembic*,
+    onbuild,
+    scripts,
+    share,
+    tools,
+    setup.py
--- a/flake8_to_ruff/src/converter.rs
+++ b/flake8_to_ruff/src/converter.rs
@@ -1,18 +1,19 @@
 use std::collections::{BTreeSet, HashMap};

 use anyhow::Result;
+use colored::Colorize;
 use ruff::flake8_pytest_style::types::{
    ParametrizeNameType, ParametrizeValuesRowType, ParametrizeValuesType,
 };
 use ruff::flake8_quotes::settings::Quote;
 use ruff::flake8_tidy_imports::settings::Strictness;
 use ruff::pydocstyle::settings::Convention;
-use ruff::registry::CheckCodePrefix;
+use ruff::registry::RuleCodePrefix;
 use ruff::settings::options::Options;
 use ruff::settings::pyproject::Pyproject;
 use ruff::{
    flake8_annotations, flake8_bugbear, flake8_errmsg, flake8_pytest_style, flake8_quotes,
-    flake8_tidy_imports, mccabe, pep8_naming, pydocstyle,
+    flake8_tidy_imports, mccabe, pep8_naming, pydocstyle, warn_user,
 };

 use crate::black::Black;
@@ -29,8 +30,8 @@ pub fn convert(
        .get("flake8")
        .expect("Unable to find flake8 section in INI file");

-    // Extract all referenced check code prefixes, to power plugin inference.
-    let mut referenced_codes: BTreeSet<CheckCodePrefix> = BTreeSet::default();
+    // Extract all referenced rule code prefixes, to power plugin inference.
+    let mut referenced_codes: BTreeSet<RuleCodePrefix> = BTreeSet::default();
    for (key, value) in flake8 {
        if let Some(value) = value {
            match key.as_str() {
@@ -60,7 +61,7 @@ pub fn convert(
        }
        let from_codes = plugin::infer_plugins_from_codes(&referenced_codes);
        if !from_codes.is_empty() {
-            eprintln!("Inferred plugins from referenced check codes: {from_codes:#?}");
+            eprintln!("Inferred plugins from referenced codes: {from_codes:#?}");
        }
        from_options.into_iter().chain(from_codes).collect()
    });
@@ -99,9 +100,14 @@ pub fn convert(
        if let Some(value) = value {
            match key.as_str() {
                // flake8
+                "builtins" => {
+                    options.builtins = Some(parser::parse_strings(value.as_ref()));
+                }
                "max-line-length" | "max_line_length" => match value.clone().parse::<usize>() {
                    Ok(line_length) => options.line_length = Some(line_length),
-                    Err(e) => eprintln!("Unable to parse '{key}' property: {e}"),
+                    Err(e) => {
+                        warn_user!("Unable to parse '{key}' property: {e}");
+                    }
                },
                "select" => {
                    // No-op (handled above).
@@ -130,7 +136,9 @@ pub fn convert(
                            options.per_file_ignores =
                                Some(parser::collect_per_file_ignores(per_file_ignores));
                        }
-                        Err(e) => eprintln!("Unable to parse '{key}' property: {e}"),
+                        Err(e) => {
+                            warn_user!("Unable to parse '{key}' property: {e}");
+                        }
                    }
                }
                // flake8-bugbear
@@ -142,46 +150,62 @@ pub fn convert(
                "suppress-none-returning" | "suppress_none_returning" => {
                    match parser::parse_bool(value.as_ref()) {
                        Ok(bool) => flake8_annotations.suppress_none_returning = Some(bool),
-                        Err(e) => eprintln!("Unable to parse '{key}' property: {e}"),
+                        Err(e) => {
+                            warn_user!("Unable to parse '{key}' property: {e}");
+                        }
                    }
                }
                "suppress-dummy-args" | "suppress_dummy_args" => {
                    match parser::parse_bool(value.as_ref()) {
                        Ok(bool) => flake8_annotations.suppress_dummy_args = Some(bool),
-                        Err(e) => eprintln!("Unable to parse '{key}' property: {e}"),
+                        Err(e) => {
+                            warn_user!("Unable to parse '{key}' property: {e}");
+                        }
                    }
                }
                "mypy-init-return" | "mypy_init_return" => {
                    match parser::parse_bool(value.as_ref()) {
                        Ok(bool) => flake8_annotations.mypy_init_return = Some(bool),
-                        Err(e) => eprintln!("Unable to parse '{key}' property: {e}"),
+                        Err(e) => {
+                            warn_user!("Unable to parse '{key}' property: {e}");
+                        }
                    }
                }
                "allow-star-arg-any" | "allow_star_arg_any" => {
                    match parser::parse_bool(value.as_ref()) {
                        Ok(bool) => flake8_annotations.allow_star_arg_any = Some(bool),
-                        Err(e) => eprintln!("Unable to parse '{key}' property: {e}"),
+                        Err(e) => {
+                            warn_user!("Unable to parse '{key}' property: {e}");
+                        }
                    }
                }
                // flake8-quotes
                "quotes" | "inline-quotes" | "inline_quotes" => match value.trim() {
                    "'" | "single" => flake8_quotes.inline_quotes = Some(Quote::Single),
                    "\"" | "double" => flake8_quotes.inline_quotes = Some(Quote::Double),
-                    _ => eprintln!("Unexpected '{key}' value: {value}"),
+                    _ => {
+                        warn_user!("Unexpected '{key}' value: {value}");
+                    }
                },
                "multiline-quotes" | "multiline_quotes" => match value.trim() {
                    "'" | "single" => flake8_quotes.multiline_quotes = Some(Quote::Single),
                    "\"" | "double" => flake8_quotes.multiline_quotes = Some(Quote::Double),
-                    _ => eprintln!("Unexpected '{key}' value: {value}"),
+                    _ => {
+                        warn_user!("Unexpected '{key}' value: {value}");
+                    }
                },
                "docstring-quotes" | "docstring_quotes" => match value.trim() {
                    "'" | "single" => flake8_quotes.docstring_quotes = Some(Quote::Single),
                    "\"" | "double" => flake8_quotes.docstring_quotes = Some(Quote::Double),
-                    _ => eprintln!("Unexpected '{key}' value: {value}"),
+                    _ => {
+                        warn_user!("Unexpected '{key}' value: {value}");
+                    }
                },
                "avoid-escape" | "avoid_escape" => match parser::parse_bool(value.as_ref()) {
                    Ok(bool) => flake8_quotes.avoid_escape = Some(bool),
-                    Err(e) => eprintln!("Unable to parse '{key}' property: {e}"),
+                    Err(e) => {
+                        warn_user!("Unable to parse '{key}' property: {e}");
+                    }
                },
                // pep8-naming
                "ignore-names" | "ignore_names" => {
@@ -201,7 +225,9 @@ pub fn convert(
                    "parents" => {
                        flake8_tidy_imports.ban_relative_imports = Some(Strictness::Parents);
                    }
-                    _ => eprintln!("Unexpected '{key}' value: {value}"),
+                    _ => {
+                        warn_user!("Unexpected '{key}' value: {value}");
+                    }
                },
                // flake8-docstrings
                "docstring-convention" => match value.trim() {
@@ -209,12 +235,16 @@ pub fn convert(
                    "numpy" => pydocstyle.convention = Some(Convention::Numpy),
                    "pep257" => pydocstyle.convention = Some(Convention::Pep257),
                    "all" => pydocstyle.convention = None,
-                    _ => eprintln!("Unexpected '{key}' value: {value}"),
+                    _ => {
+                        warn_user!("Unexpected '{key}' value: {value}");
+                    }
                },
                // mccabe
                "max-complexity" | "max_complexity" => match value.clone().parse::<usize>() {
                    Ok(max_complexity) => mccabe.max_complexity = Some(max_complexity),
-                    Err(e) => eprintln!("Unable to parse '{key}' property: {e}"),
+                    Err(e) => {
+                        warn_user!("Unable to parse '{key}' property: {e}");
+                    }
                },
                // flake8-errmsg
                "errmsg-max-string-length" | "errmsg_max_string_length" => {
@@ -222,14 +252,18 @@ pub fn convert(
                        Ok(max_string_length) => {
                            flake8_errmsg.max_string_length = Some(max_string_length);
                        }
-                        Err(e) => eprintln!("Unable to parse '{key}' property: {e}"),
+                        Err(e) => {
+                            warn_user!("Unable to parse '{key}' property: {e}");
+                        }
                    }
                }
                // flake8-pytest-style
                "pytest-fixture-no-parentheses" | "pytest_fixture_no_parentheses " => {
                    match parser::parse_bool(value.as_ref()) {
                        Ok(bool) => flake8_pytest_style.fixture_parentheses = Some(!bool),
-                        Err(e) => eprintln!("Unable to parse '{key}' property: {e}"),
+                        Err(e) => {
+                            warn_user!("Unable to parse '{key}' property: {e}");
+                        }
                    }
                }
                "pytest-parametrize-names-type" | "pytest_parametrize_names_type" => {
@@ -246,7 +280,9 @@ pub fn convert(
                            flake8_pytest_style.parametrize_names_type =
                                Some(ParametrizeNameType::List);
                        }
-                        _ => eprintln!("Unexpected '{key}' value: {value}"),
+                        _ => {
+                            warn_user!("Unexpected '{key}' value: {value}");
+                        }
                    }
                }
                "pytest-parametrize-values-type" | "pytest_parametrize_values_type" => {
@@ -259,7 +295,9 @@ pub fn convert(
                            flake8_pytest_style.parametrize_values_type =
                                Some(ParametrizeValuesType::List);
                        }
-                        _ => eprintln!("Unexpected '{key}' value: {value}"),
+                        _ => {
+                            warn_user!("Unexpected '{key}' value: {value}");
+                        }
                    }
                }
                "pytest-parametrize-values-row-type" | "pytest_parametrize_values_row_type" => {
@@ -272,7 +310,9 @@ pub fn convert(
                            flake8_pytest_style.parametrize_values_row_type =
                                Some(ParametrizeValuesRowType::List);
                        }
-                        _ => eprintln!("Unexpected '{key}' value: {value}"),
+                        _ => {
+                            warn_user!("Unexpected '{key}' value: {value}");
+                        }
                    }
                }
                "pytest-raises-require-match-for" | "pytest_raises_require_match_for" => {
@@ -282,11 +322,15 @@ pub fn convert(
                "pytest-mark-no-parentheses" | "pytest_mark_no_parentheses" => {
                    match parser::parse_bool(value.as_ref()) {
                        Ok(bool) => flake8_pytest_style.mark_parentheses = Some(!bool),
-                        Err(e) => eprintln!("Unable to parse '{key}' property: {e}"),
+                        Err(e) => {
+                            warn_user!("Unable to parse '{key}' property: {e}");
+                        }
                    }
                }
                // Unknown
-                _ => eprintln!("Skipping unsupported property: {key}"),
+                _ => {
+                    warn_user!("Skipping unsupported property: {}", key);
+                }
            }
        }
    }
@@ -345,7 +389,7 @@ mod tests {

    use anyhow::Result;
    use ruff::pydocstyle::settings::Convention;
-    use ruff::registry::CheckCodePrefix;
+    use ruff::registry::RuleCodePrefix;
    use ruff::settings::options::Options;
    use ruff::settings::pyproject::Pyproject;
    use ruff::{flake8_quotes, pydocstyle};
@@ -362,6 +406,7 @@ mod tests {
        )?;
        let expected = Pyproject::new(Options {
            allowed_confusables: None,
+            builtins: None,
            cache_dir: None,
            dummy_variable_rgx: None,
            exclude: None,
@@ -382,14 +427,15 @@ mod tests {
            required_version: None,
            respect_gitignore: None,
            select: Some(vec![
-                CheckCodePrefix::E,
-                CheckCodePrefix::F,
-                CheckCodePrefix::W,
+                RuleCodePrefix::E,
+                RuleCodePrefix::F,
+                RuleCodePrefix::W,
            ]),
            show_source: None,
            src: None,
            target_version: None,
            unfixable: None,
+            typing_modules: None,
            task_tags: None,
            update_check: None,
            flake8_annotations: None,
@@ -425,6 +471,7 @@ mod tests {
        )?;
        let expected = Pyproject::new(Options {
            allowed_confusables: None,
+            builtins: None,
            cache_dir: None,
            dummy_variable_rgx: None,
            exclude: None,
@@ -445,14 +492,15 @@ mod tests {
            required_version: None,
            respect_gitignore: None,
            select: Some(vec![
-                CheckCodePrefix::E,
-                CheckCodePrefix::F,
-                CheckCodePrefix::W,
+                RuleCodePrefix::E,
+                RuleCodePrefix::F,
+                RuleCodePrefix::W,
            ]),
            show_source: None,
            src: None,
            target_version: None,
            unfixable: None,
+            typing_modules: None,
            task_tags: None,
            update_check: None,
            flake8_annotations: None,
@@ -488,6 +536,7 @@ mod tests {
        )?;
        let expected = Pyproject::new(Options {
            allowed_confusables: None,
+            builtins: None,
            cache_dir: None,
            dummy_variable_rgx: None,
            exclude: None,
@@ -508,14 +557,15 @@ mod tests {
            required_version: None,
            respect_gitignore: None,
            select: Some(vec![
-                CheckCodePrefix::E,
-                CheckCodePrefix::F,
-                CheckCodePrefix::W,
+                RuleCodePrefix::E,
+                RuleCodePrefix::F,
+                RuleCodePrefix::W,
            ]),
            show_source: None,
            src: None,
            target_version: None,
            unfixable: None,
+            typing_modules: None,
            task_tags: None,
            update_check: None,
            flake8_annotations: None,
@@ -551,6 +601,7 @@ mod tests {
        )?;
        let expected = Pyproject::new(Options {
            allowed_confusables: None,
+            builtins: None,
            cache_dir: None,
            dummy_variable_rgx: None,
            exclude: None,
@@ -571,14 +622,15 @@ mod tests {
            required_version: None,
            respect_gitignore: None,
            select: Some(vec![
-                CheckCodePrefix::E,
-                CheckCodePrefix::F,
-                CheckCodePrefix::W,
+                RuleCodePrefix::E,
+                RuleCodePrefix::F,
+                RuleCodePrefix::W,
            ]),
            show_source: None,
            src: None,
            target_version: None,
            unfixable: None,
+            typing_modules: None,
            task_tags: None,
            update_check: None,
            flake8_annotations: None,
@@ -614,6 +666,7 @@ mod tests {
        )?;
        let expected = Pyproject::new(Options {
            allowed_confusables: None,
+            builtins: None,
            cache_dir: None,
            dummy_variable_rgx: None,
            exclude: None,
@@ -634,14 +687,15 @@ mod tests {
            required_version: None,
            respect_gitignore: None,
            select: Some(vec![
-                CheckCodePrefix::E,
-                CheckCodePrefix::F,
-                CheckCodePrefix::W,
+                RuleCodePrefix::E,
+                RuleCodePrefix::F,
+                RuleCodePrefix::W,
            ]),
            show_source: None,
            src: None,
            target_version: None,
            unfixable: None,
+            typing_modules: None,
            task_tags: None,
            update_check: None,
            flake8_annotations: None,
@@ -685,6 +739,7 @@ mod tests {
        )?;
        let expected = Pyproject::new(Options {
            allowed_confusables: None,
+            builtins: None,
            cache_dir: None,
            dummy_variable_rgx: None,
            exclude: None,
@@ -705,15 +760,16 @@ mod tests {
            required_version: None,
            respect_gitignore: None,
            select: Some(vec![
-                CheckCodePrefix::D,
-                CheckCodePrefix::E,
-                CheckCodePrefix::F,
-                CheckCodePrefix::W,
+                RuleCodePrefix::D,
+                RuleCodePrefix::E,
+                RuleCodePrefix::F,
+                RuleCodePrefix::W,
            ]),
            show_source: None,
            src: None,
            target_version: None,
            unfixable: None,
+            typing_modules: None,
            task_tags: None,
            update_check: None,
            flake8_annotations: None,
@@ -751,6 +807,7 @@ mod tests {
        )?;
        let expected = Pyproject::new(Options {
            allowed_confusables: None,
+            builtins: None,
            cache_dir: None,
            dummy_variable_rgx: None,
            exclude: None,
@@ -771,15 +828,16 @@ mod tests {
            required_version: None,
            respect_gitignore: None,
            select: Some(vec![
-                CheckCodePrefix::E,
-                CheckCodePrefix::F,
-                CheckCodePrefix::Q,
-                CheckCodePrefix::W,
+                RuleCodePrefix::E,
+                RuleCodePrefix::F,
+                RuleCodePrefix::Q,
+                RuleCodePrefix::W,
            ]),
            show_source: None,
            src: None,
            target_version: None,
            unfixable: None,
+            typing_modules: None,
            task_tags: None,
            update_check: None,
            flake8_annotations: None,
--- a/flake8_to_ruff/src/parser.rs
+++ b/flake8_to_ruff/src/parser.rs
@@ -1,18 +1,20 @@
 use std::str::FromStr;

 use anyhow::{bail, Result};
+use colored::Colorize;
 use once_cell::sync::Lazy;
 use regex::Regex;
-use ruff::registry::{CheckCodePrefix, PREFIX_REDIRECTS};
+use ruff::registry::{RuleCodePrefix, PREFIX_REDIRECTS};
 use ruff::settings::types::PatternPrefixPair;
+use ruff::warn_user;
 use rustc_hash::FxHashMap;

 static COMMA_SEPARATED_LIST_RE: Lazy<Regex> = Lazy::new(|| Regex::new(r"[,\s]").unwrap());

-/// Parse a comma-separated list of `CheckCodePrefix` values (e.g.,
+/// Parse a comma-separated list of `RuleCodePrefix` values (e.g.,
 /// "F401,E501").
-pub fn parse_prefix_codes(value: &str) -> Vec<CheckCodePrefix> {
-    let mut codes: Vec<CheckCodePrefix> = vec![];
+pub fn parse_prefix_codes(value: &str) -> Vec<RuleCodePrefix> {
+    let mut codes: Vec<RuleCodePrefix> = vec![];
    for code in COMMA_SEPARATED_LIST_RE.split(value) {
        let code = code.trim();
        if code.is_empty() {
@@ -20,10 +22,10 @@ pub fn parse_prefix_codes(value: &str) -> Vec<CheckCodePrefix> {
        }
        if let Some(code) = PREFIX_REDIRECTS.get(code) {
            codes.push(code.clone());
-        } else if let Ok(code) = CheckCodePrefix::from_str(code) {
+        } else if let Ok(code) = RuleCodePrefix::from_str(code) {
            codes.push(code);
        } else {
-            eprintln!("Unsupported prefix code: {code}");
+            warn_user!("Unsupported prefix code: {code}");
        }
    }
    codes
@@ -81,7 +83,8 @@ impl State {
        }
    }

-    /// Generate the list of `StrCheckCodePair` pairs for the current state.
+    /// Generate the list of `StrRuleCodePair` pairs for the current
+    /// state.
    fn parse(&self) -> Vec<PatternPrefixPair> {
        let mut codes: Vec<PatternPrefixPair> = vec![];
        for code in &self.codes {
@@ -92,7 +95,7 @@ impl State {
                        prefix: code.clone(),
                    });
                }
-            } else if let Ok(code) = CheckCodePrefix::from_str(code) {
+            } else if let Ok(code) = RuleCodePrefix::from_str(code) {
                for filename in &self.filenames {
                    codes.push(PatternPrefixPair {
                        pattern: filename.clone(),
@@ -100,7 +103,7 @@ impl State {
                    });
                }
            } else {
-                eprintln!("Unsupported prefix code: {code}");
+                warn_user!("Unsupported prefix code: {code}");
            }
        }
        codes
@@ -186,8 +189,8 @@ pub fn parse_files_to_codes_mapping(value: &str) -> Result<Vec<PatternPrefixPair
 /// Collect a list of `PatternPrefixPair` structs as a `BTreeMap`.
 pub fn collect_per_file_ignores(
    pairs: Vec<PatternPrefixPair>,
-) -> FxHashMap<String, Vec<CheckCodePrefix>> {
-    let mut per_file_ignores: FxHashMap<String, Vec<CheckCodePrefix>> = FxHashMap::default();
+) -> FxHashMap<String, Vec<RuleCodePrefix>> {
+    let mut per_file_ignores: FxHashMap<String, Vec<RuleCodePrefix>> = FxHashMap::default();
    for pair in pairs {
        per_file_ignores
            .entry(pair.pattern)
@@ -200,7 +203,7 @@ pub fn collect_per_file_ignores(
 #[cfg(test)]
 mod tests {
    use anyhow::Result;
-    use ruff::registry::CheckCodePrefix;
+    use ruff::registry::RuleCodePrefix;
    use ruff::settings::types::PatternPrefixPair;

    use crate::parser::{parse_files_to_codes_mapping, parse_prefix_codes, parse_strings};
@@ -208,27 +211,27 @@ mod tests {
    #[test]
    fn it_parses_prefix_codes() {
        let actual = parse_prefix_codes("");
-        let expected: Vec<CheckCodePrefix> = vec![];
+        let expected: Vec<RuleCodePrefix> = vec![];
        assert_eq!(actual, expected);

        let actual = parse_prefix_codes(" ");
-        let expected: Vec<CheckCodePrefix> = vec![];
+        let expected: Vec<RuleCodePrefix> = vec![];
        assert_eq!(actual, expected);

        let actual = parse_prefix_codes("F401");
-        let expected = vec![CheckCodePrefix::F401];
+        let expected = vec![RuleCodePrefix::F401];
        assert_eq!(actual, expected);

        let actual = parse_prefix_codes("F401,");
-        let expected = vec![CheckCodePrefix::F401];
+        let expected = vec![RuleCodePrefix::F401];
        assert_eq!(actual, expected);

        let actual = parse_prefix_codes("F401,E501");
-        let expected = vec![CheckCodePrefix::F401, CheckCodePrefix::E501];
+        let expected = vec![RuleCodePrefix::F401, RuleCodePrefix::E501];
        assert_eq!(actual, expected);

        let actual = parse_prefix_codes("F401, E501");
-        let expected = vec![CheckCodePrefix::F401, CheckCodePrefix::E501];
+        let expected = vec![RuleCodePrefix::F401, RuleCodePrefix::E501];
        assert_eq!(actual, expected);
    }

@@ -281,11 +284,11 @@ mod tests {
        let expected: Vec<PatternPrefixPair> = vec![
            PatternPrefixPair {
                pattern: "locust/test/*".to_string(),
-                prefix: CheckCodePrefix::F841,
+                prefix: RuleCodePrefix::F841,
            },
            PatternPrefixPair {
                pattern: "examples/*".to_string(),
-                prefix: CheckCodePrefix::F841,
+                prefix: RuleCodePrefix::F841,
            },
        ];
        assert_eq!(actual, expected);
@@ -301,23 +304,23 @@ mod tests {
        let expected: Vec<PatternPrefixPair> = vec![
            PatternPrefixPair {
                pattern: "t/*".to_string(),
-                prefix: CheckCodePrefix::D,
+                prefix: RuleCodePrefix::D,
            },
            PatternPrefixPair {
                pattern: "setup.py".to_string(),
-                prefix: CheckCodePrefix::D,
+                prefix: RuleCodePrefix::D,
            },
            PatternPrefixPair {
                pattern: "examples/*".to_string(),
-                prefix: CheckCodePrefix::D,
+                prefix: RuleCodePrefix::D,
            },
            PatternPrefixPair {
                pattern: "docs/*".to_string(),
-                prefix: CheckCodePrefix::D,
+                prefix: RuleCodePrefix::D,
            },
            PatternPrefixPair {
                pattern: "extra/*".to_string(),
-                prefix: CheckCodePrefix::D,
+                prefix: RuleCodePrefix::D,
            },
        ];
        assert_eq!(actual, expected);
@@ -339,47 +342,47 @@ mod tests {
        let expected: Vec<PatternPrefixPair> = vec![
            PatternPrefixPair {
                pattern: "scrapy/__init__.py".to_string(),
-                prefix: CheckCodePrefix::E402,
+                prefix: RuleCodePrefix::E402,
            },
            PatternPrefixPair {
                pattern: "scrapy/core/downloader/handlers/http.py".to_string(),
-                prefix: CheckCodePrefix::F401,
+                prefix: RuleCodePrefix::F401,
            },
            PatternPrefixPair {
                pattern: "scrapy/http/__init__.py".to_string(),
-                prefix: CheckCodePrefix::F401,
+                prefix: RuleCodePrefix::F401,
            },
            PatternPrefixPair {
                pattern: "scrapy/linkextractors/__init__.py".to_string(),
-                prefix: CheckCodePrefix::E402,
+                prefix: RuleCodePrefix::E402,
            },
            PatternPrefixPair {
                pattern: "scrapy/linkextractors/__init__.py".to_string(),
-                prefix: CheckCodePrefix::F401,
+                prefix: RuleCodePrefix::F401,
            },
            PatternPrefixPair {
                pattern: "scrapy/selector/__init__.py".to_string(),
-                prefix: CheckCodePrefix::F401,
+                prefix: RuleCodePrefix::F401,
            },
            PatternPrefixPair {
                pattern: "scrapy/spiders/__init__.py".to_string(),
-                prefix: CheckCodePrefix::E402,
+                prefix: RuleCodePrefix::E402,
            },
            PatternPrefixPair {
                pattern: "scrapy/spiders/__init__.py".to_string(),
-                prefix: CheckCodePrefix::F401,
+                prefix: RuleCodePrefix::F401,
            },
            PatternPrefixPair {
                pattern: "scrapy/utils/url.py".to_string(),
-                prefix: CheckCodePrefix::F403,
+                prefix: RuleCodePrefix::F403,
            },
            PatternPrefixPair {
                pattern: "scrapy/utils/url.py".to_string(),
-                prefix: CheckCodePrefix::F405,
+                prefix: RuleCodePrefix::F405,
            },
            PatternPrefixPair {
                pattern: "tests/test_loader.py".to_string(),
-                prefix: CheckCodePrefix::E741,
+                prefix: RuleCodePrefix::E741,
            },
        ];
        assert_eq!(actual, expected);
--- a/flake8_to_ruff/src/plugin.rs
+++ b/flake8_to_ruff/src/plugin.rs
@@ -3,7 +3,7 @@ use std::fmt;
 use std::str::FromStr;

 use anyhow::anyhow;
-use ruff::registry::CheckCodePrefix;
+use ruff::registry::RuleCodePrefix;

 #[derive(Clone, Ord, PartialOrd, Eq, PartialEq)]
 pub enum Plugin {
@@ -97,53 +97,32 @@ impl fmt::Debug for Plugin {
 }

 impl Plugin {
-    pub fn prefix(&self) -> CheckCodePrefix {
+    pub fn prefix(&self) -> RuleCodePrefix {
        match self {
-            Plugin::Flake8Annotations => CheckCodePrefix::ANN,
-            Plugin::Flake8Bandit => CheckCodePrefix::S,
+            Plugin::Flake8Annotations => RuleCodePrefix::ANN,
+            Plugin::Flake8Bandit => RuleCodePrefix::S,
            // TODO(charlie): Handle rename of `B` to `BLE`.
-            Plugin::Flake8BlindExcept => CheckCodePrefix::BLE,
-            Plugin::Flake8Bugbear => CheckCodePrefix::B,
-            Plugin::Flake8Builtins => CheckCodePrefix::A,
-            Plugin::Flake8Comprehensions => CheckCodePrefix::C4,
-            Plugin::Flake8Datetimez => CheckCodePrefix::DTZ,
-            Plugin::Flake8Debugger => CheckCodePrefix::T1,
-            Plugin::Flake8Docstrings => CheckCodePrefix::D,
+            Plugin::Flake8BlindExcept => RuleCodePrefix::BLE,
+            Plugin::Flake8Bugbear => RuleCodePrefix::B,
+            Plugin::Flake8Builtins => RuleCodePrefix::A,
+            Plugin::Flake8Comprehensions => RuleCodePrefix::C4,
+            Plugin::Flake8Datetimez => RuleCodePrefix::DTZ,
+            Plugin::Flake8Debugger => RuleCodePrefix::T1,
+            Plugin::Flake8Docstrings => RuleCodePrefix::D,
            // TODO(charlie): Handle rename of `E` to `ERA`.
-            Plugin::Flake8Eradicate => CheckCodePrefix::ERA,
-            Plugin::Flake8ErrMsg => CheckCodePrefix::EM,
-            Plugin::Flake8ImplicitStrConcat => CheckCodePrefix::ISC,
-            Plugin::Flake8Print => CheckCodePrefix::T2,
-            Plugin::Flake8PytestStyle => CheckCodePrefix::PT,
-            Plugin::Flake8Quotes => CheckCodePrefix::Q,
-            Plugin::Flake8Return => CheckCodePrefix::RET,
-            Plugin::Flake8Simplify => CheckCodePrefix::SIM,
-            Plugin::Flake8TidyImports => CheckCodePrefix::TID25,
-            Plugin::McCabe => CheckCodePrefix::C9,
-            Plugin::PandasVet => CheckCodePrefix::PD,
-            Plugin::PEP8Naming => CheckCodePrefix::N,
-            Plugin::Pyupgrade => CheckCodePrefix::UP,
-        }
-    }
-}
-
-pub enum DocstringConvention {
-    All,
-    Pep257,
-    Numpy,
-    Google,
-}
-
-impl FromStr for DocstringConvention {
-    type Err = anyhow::Error;
-
-    fn from_str(string: &str) -> Result<Self, Self::Err> {
-        match string {
-            "all" => Ok(DocstringConvention::All),
-            "pep257" => Ok(DocstringConvention::Pep257),
-            "numpy" => Ok(DocstringConvention::Numpy),
-            "google" => Ok(DocstringConvention::Google),
-            _ => Err(anyhow!("Unknown docstring convention: {string}")),
+            Plugin::Flake8Eradicate => RuleCodePrefix::ERA,
+            Plugin::Flake8ErrMsg => RuleCodePrefix::EM,
+            Plugin::Flake8ImplicitStrConcat => RuleCodePrefix::ISC,
+            Plugin::Flake8Print => RuleCodePrefix::T2,
+            Plugin::Flake8PytestStyle => RuleCodePrefix::PT,
+            Plugin::Flake8Quotes => RuleCodePrefix::Q,
+            Plugin::Flake8Return => RuleCodePrefix::RET,
+            Plugin::Flake8Simplify => RuleCodePrefix::SIM,
+            Plugin::Flake8TidyImports => RuleCodePrefix::TID25,
+            Plugin::McCabe => RuleCodePrefix::C9,
+            Plugin::PandasVet => RuleCodePrefix::PD,
+            Plugin::PEP8Naming => RuleCodePrefix::N,
+            Plugin::Pyupgrade => RuleCodePrefix::UP,
        }
    }
 }
@@ -269,7 +248,7 @@ pub fn infer_plugins_from_options(flake8: &HashMap<String, Option<String>>) -> V
 ///
 /// For example, if the user ignores `ANN101`, we should infer that
 /// `flake8-annotations` is active.
-pub fn infer_plugins_from_codes(codes: &BTreeSet<CheckCodePrefix>) -> Vec<Plugin> {
+pub fn infer_plugins_from_codes(codes: &BTreeSet<RuleCodePrefix>) -> Vec<Plugin> {
    [
        Plugin::Flake8Annotations,
        Plugin::Flake8Bandit,
@@ -307,9 +286,10 @@ pub fn infer_plugins_from_codes(codes: &BTreeSet<CheckCodePrefix>) -> Vec<Plugin
    .collect()
 }

-/// Resolve the set of enabled `CheckCodePrefix` values for the given plugins.
-pub fn resolve_select(plugins: &[Plugin]) -> BTreeSet<CheckCodePrefix> {
-    let mut select = BTreeSet::from([CheckCodePrefix::F, CheckCodePrefix::E, CheckCodePrefix::W]);
+/// Resolve the set of enabled `RuleCodePrefix` values for the given
+/// plugins.
+pub fn resolve_select(plugins: &[Plugin]) -> BTreeSet<RuleCodePrefix> {
+    let mut select = BTreeSet::from([RuleCodePrefix::F, RuleCodePrefix::E, RuleCodePrefix::W]);
    select.extend(plugins.iter().map(Plugin::prefix));
    select
 }
--- a/playground/src/Editor/Editor.tsx
+++ b/playground/src/Editor/Editor.tsx
@@ -1,6 +1,11 @@
 import { useCallback, useEffect, useState } from "react";
 import { DEFAULT_PYTHON_SOURCE } from "../constants";
-import init, { check, Check, currentVersion, defaultSettings } from "../pkg";
+import init, {
+  check,
+  Diagnostic,
+  currentVersion,
+  defaultSettings,
+} from "../pkg";
 import { ErrorMessage } from "./ErrorMessage";
 import Header from "./Header";
 import { useTheme } from "./theme";
@@ -18,7 +23,7 @@ export default function Editor() {
  const [edit, setEdit] = useState<number>(0);
  const [settingsSource, setSettingsSource] = useState<string | null>(null);
  const [pythonSource, setPythonSource] = useState<string | null>(null);
-  const [checks, setChecks] = useState<Check[]>([]);
+  const [diagnostics, setDiagnostics] = useState<Diagnostic[]>([]);
  const [error, setError] = useState<string | null>(null);
  const [theme, setTheme] = useTheme();

@@ -32,25 +37,25 @@ export default function Editor() {
    }

    let config: any;
-    let checks: Check[];
+    let diagnostics: Diagnostic[];

    try {
      config = JSON.parse(settingsSource);
    } catch (e) {
-      setChecks([]);
+      setDiagnostics([]);
      setError((e as Error).message);
      return;
    }

    try {
-      checks = check(pythonSource, config);
+      diagnostics = check(pythonSource, config);
    } catch (e) {
      setError(e as string);
      return;
    }

    setError(null);
-    setChecks(checks);
+    setDiagnostics(diagnostics);
  }, [initialized, settingsSource, pythonSource]);

  useEffect(() => {
@@ -122,7 +127,7 @@ export default function Editor() {
              visible={tab === "Source"}
              source={pythonSource}
              theme={theme}
-              checks={checks}
+              diagnostics={diagnostics}
              onChange={handlePythonSourceChange}
            />
            <SettingsEditor
--- a/playground/src/Editor/SourceEditor.tsx
+++ b/playground/src/Editor/SourceEditor.tsx
@@ -5,19 +5,19 @@
 import Editor, { useMonaco } from "@monaco-editor/react";
 import { MarkerSeverity, MarkerTag } from "monaco-editor";
 import { useCallback, useEffect } from "react";
-import { Check } from "../pkg";
+import { Diagnostic } from "../pkg";
 import { Theme } from "./theme";

 export default function SourceEditor({
  visible,
  source,
  theme,
-  checks,
+  diagnostics,
  onChange,
 }: {
  visible: boolean;
  source: string;
-  checks: Check[];
+  diagnostics: Diagnostic[];
  theme: Theme;
  onChange: (pythonSource: string) => void;
 }) {
@@ -33,15 +33,15 @@ export default function SourceEditor({
    editor.setModelMarkers(
      model,
      "owner",
-      checks.map((check) => ({
-        startLineNumber: check.location.row,
-        startColumn: check.location.column + 1,
-        endLineNumber: check.end_location.row,
-        endColumn: check.end_location.column + 1,
-        message: `${check.code}: ${check.message}`,
+      diagnostics.map((diagnostic) => ({
+        startLineNumber: diagnostic.location.row,
+        startColumn: diagnostic.location.column + 1,
+        endLineNumber: diagnostic.end_location.row,
+        endColumn: diagnostic.end_location.column + 1,
+        message: `${diagnostic.code}: ${diagnostic.message}`,
        severity: MarkerSeverity.Error,
        tags:
-          check.code === "F401" || check.code === "F841"
+          diagnostic.code === "F401" || diagnostic.code === "F841"
            ? [MarkerTag.Unnecessary]
            : [],
      })),
@@ -52,7 +52,7 @@ export default function SourceEditor({
      {
        // @ts-expect-error: The type definition is wrong.
        provideCodeActions: function (model, position) {
-          const actions = checks
+          const actions = diagnostics
            .filter((check) => position.startLineNumber === check.location.row)
            .filter((check) => check.fix)
            .map((check) => ({
@@ -89,7 +89,7 @@ export default function SourceEditor({
    return () => {
      codeActionProvider?.dispose();
    };
-  }, [checks, monaco]);
+  }, [diagnostics, monaco]);

  const handleChange = useCallback(
    (value: string | undefined) => {
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -1,10 +1,13 @@
 [build-system]
-requires = ["maturin>=0.14,<0.15"]
+requires = ["maturin>=0.14.10,<0.15"]
+# We depend on >=0.14.10 because we specify name in
+# [package.metadata.maturin] in ruff_cli/Cargo.toml.
+
 build-backend = "maturin"

 [project]
 name = "ruff"
-version = "0.0.215"
+version = "0.0.221"
 description = "An extremely fast Python linter, written in Rust."
 authors = [
  { name = "Charlie Marsh", email = "charlie.r.marsh@gmail.com" },
@@ -35,6 +38,8 @@ urls = { repository = "https://github.com/charliermarsh/ruff" }

 [tool.maturin]
 bindings = "bin"
+manifest-path = "ruff_cli/Cargo.toml"
+python-source = "python"
 strip = true

 [tool.setuptools]
--- a/python/ruff/init.py
+++ b/python/ruff/init.py
--- a/python/ruff/main.py
+++ b/python/ruff/main.py
--- a/resources/test/fixtures/flake8_annotations/allow_nested_overload.py
+++ b/resources/test/fixtures/flake8_annotations/allow_nested_overload.py
@@ -0,0 +1,9 @@
+class C:
+    from typing import overload
+
+    @overload
+    def f(self, x: int, y: int) -> None:
+        ...
+
+    def f(self, x, y):
+        pass
--- a/resources/test/fixtures/flake8_bandit/S508.py
+++ b/resources/test/fixtures/flake8_bandit/S508.py
@@ -0,0 +1,6 @@
+from pysnmp.hlapi import CommunityData
+
+CommunityData("public", mpModel=0)  # S508
+CommunityData("public", mpModel=1)  # S508
+
+CommunityData("public", mpModel=2)  # OK
--- a/resources/test/fixtures/flake8_bandit/S509.py
+++ b/resources/test/fixtures/flake8_bandit/S509.py
@@ -0,0 +1,7 @@
+from pysnmp.hlapi import UsmUserData
+
+
+insecure = UsmUserData("securityName")  # S509
+auth_no_priv = UsmUserData("securityName", "authName")  # S509
+
+less_insecure = UsmUserData("securityName", "authName", "privName")  # OK
--- a/resources/test/fixtures/flake8_bandit/S701.py
+++ b/resources/test/fixtures/flake8_bandit/S701.py
@@ -0,0 +1,29 @@
+import jinja2
+from jinja2 import Environment, select_autoescape
+templateLoader = jinja2.FileSystemLoader( searchpath="/" )
+something = ''
+
+Environment(loader=templateLoader, load=templateLoader, autoescape=True)
+templateEnv = jinja2.Environment(autoescape=True,
+        loader=templateLoader )
+Environment(loader=templateLoader, load=templateLoader, autoescape=something)  # S701
+templateEnv = jinja2.Environment(autoescape=False, loader=templateLoader )  # S701
+Environment(loader=templateLoader,
+            load=templateLoader,
+            autoescape=False)  # S701
+
+Environment(loader=templateLoader,  # S701
+            load=templateLoader)
+
+Environment(loader=templateLoader, autoescape=select_autoescape())
+
+Environment(loader=templateLoader,
+            autoescape=select_autoescape(['html', 'htm', 'xml']))
+
+Environment(loader=templateLoader,
+            autoescape=jinja2.select_autoescape(['html', 'htm', 'xml']))
+
+
+def fake_func():
+    return 'foobar'
+Environment(loader=templateLoader, autoescape=fake_func())  # S701
--- a/resources/test/fixtures/flake8_bugbear/B023.py
+++ b/resources/test/fixtures/flake8_bugbear/B023.py
@@ -25,10 +25,10 @@ for x in range(3):


 def check_inside_functions_too():
-    ls = [lambda: x for x in range(2)]
-    st = {lambda: x for x in range(2)}
-    gn = (lambda: x for x in range(2))
-    dt = {x: lambda: x for x in range(2)}
+    ls = [lambda: x for x in range(2)]  # error
+    st = {lambda: x for x in range(2)}  # error
+    gn = (lambda: x for x in range(2))  # error
+    dt = {x: lambda: x for x in range(2)}  # error


 async def pointless_async_iterable():
@@ -37,9 +37,9 @@ async def pointless_async_iterable():

 async def container_for_problems():
    async for x in pointless_async_iterable():
-        functions.append(lambda: x)
+        functions.append(lambda: x)  # error

-    [lambda: x async for x in pointless_async_iterable()]
+    [lambda: x async for x in pointless_async_iterable()]  # error


 a = 10
@@ -47,10 +47,10 @@ b = 0
 while True:
    a = a_ = a - 1
    b += 1
-    functions.append(lambda: a)
-    functions.append(lambda: a_)
-    functions.append(lambda: b)
-    functions.append(lambda: c)  # not a name error because of late binding!
+    functions.append(lambda: a)  # error
+    functions.append(lambda: a_)  # error
+    functions.append(lambda: b)  # error
+    functions.append(lambda: c)  # error, but not a name error due to late binding
    c: bool = a > 3
    if not c:
        break
@@ -58,7 +58,7 @@ while True:
 # Nested loops should not duplicate reports
 for j in range(2):
    for k in range(3):
-        lambda: j * k
+        lambda: j * k  # error


 for j, k, l in [(1, 2, 3)]:
@@ -80,3 +80,95 @@ for var in range(2):

 for i in range(3):
    lambda: f"{i}"
+
+
+# `query` is defined in the function, so also defining it in the loop should be OK.
+for name in ["a", "b"]:
+    query = name
+
+    def myfunc(x):
+        query = x
+        query_post = x
+        _ = query
+        _ = query_post
+
+    query_post = name  # in case iteration order matters
+
+
+# Bug here because two dict comprehensions reference `name`, one of which is inside
+# the lambda.  This should be totally fine, of course.
+_ = {
+    k: v
+    for k, v in reduce(
+        lambda data, event: merge_mappings(
+            [data, {name: f(caches, data, event) for name, f in xx}]
+        ),
+        events,
+        {name: getattr(group, name) for name in yy},
+    ).items()
+    if k in backfill_fields
+}
+
+
+# OK to define lambdas if they're immediately consumed, typically as the `key=`
+# argument or in a consumed `filter()` (even if a comprehension is better style)
+for x in range(2):
+    # It's not a complete get-out-of-linting-free construct - these should fail:
+    min([None, lambda: x], key=repr)
+    sorted([None, lambda: x], key=repr)
+    any(filter(bool, [None, lambda: x]))
+    list(filter(bool, [None, lambda: x]))
+    all(reduce(bool, [None, lambda: x]))
+
+    # But all these should be OK:
+    min(range(3), key=lambda y: x * y)
+    max(range(3), key=lambda y: x * y)
+    sorted(range(3), key=lambda y: x * y)
+
+    any(map(lambda y: x < y, range(3)))
+    all(map(lambda y: x < y, range(3)))
+    set(map(lambda y: x < y, range(3)))
+    list(map(lambda y: x < y, range(3)))
+    tuple(map(lambda y: x < y, range(3)))
+    sorted(map(lambda y: x < y, range(3)))
+    frozenset(map(lambda y: x < y, range(3)))
+
+    any(filter(lambda y: x < y, range(3)))
+    all(filter(lambda y: x < y, range(3)))
+    set(filter(lambda y: x < y, range(3)))
+    list(filter(lambda y: x < y, range(3)))
+    tuple(filter(lambda y: x < y, range(3)))
+    sorted(filter(lambda y: x < y, range(3)))
+    frozenset(filter(lambda y: x < y, range(3)))
+
+    any(reduce(lambda y: x | y, range(3)))
+    all(reduce(lambda y: x | y, range(3)))
+    set(reduce(lambda y: x | y, range(3)))
+    list(reduce(lambda y: x | y, range(3)))
+    tuple(reduce(lambda y: x | y, range(3)))
+    sorted(reduce(lambda y: x | y, range(3)))
+    frozenset(reduce(lambda y: x | y, range(3)))
+
+    import functools
+
+    any(functools.reduce(lambda y: x | y, range(3)))
+    all(functools.reduce(lambda y: x | y, range(3)))
+    set(functools.reduce(lambda y: x | y, range(3)))
+    list(functools.reduce(lambda y: x | y, range(3)))
+    tuple(functools.reduce(lambda y: x | y, range(3)))
+    sorted(functools.reduce(lambda y: x | y, range(3)))
+    frozenset(functools.reduce(lambda y: x | y, range(3)))
+
+# OK because the lambda which references a loop variable is defined in a `return`
+# statement, and after we return the loop variable can't be redefined.
+# In principle we could do something fancy with `break`, but it's not worth it.
+def iter_f(names):
+    for name in names:
+        if exists(name):
+            return lambda: name if exists(name) else None
+
+        if foo(name):
+            return [lambda: name]  # known false alarm
+
+        if False:
+            return [lambda: i for i in range(3)]  # error
--- a/resources/test/fixtures/flake8_bugbear/B024.py
+++ b/resources/test/fixtures/flake8_bugbear/B024.py
@@ -1,15 +1,16 @@
 """
 Should emit:
-B024 - on lines 17, 34, 52, 58, 69, 74, 79, 84, 89
+B024 - on lines 18, 71, 82, 87, 92, 141
 """

 import abc
 import abc as notabc
 from abc import ABC, ABCMeta
-from abc import abstractmethod
+from abc import abstractmethod, abstractproperty
 from abc import abstractmethod as abstract
 from abc import abstractmethod as abstractaoeuaoeuaoeu
 from abc import abstractmethod as notabstract
+from abc import abstractproperty as notabstract_property

 import foo

@@ -49,12 +50,24 @@ class Base_6(ABC):
        foo()


-class Base_7(ABC):  # error
+class Base_7(ABC):
    @notabstract
    def method(self):
        foo()


+class Base_8(ABC):
+    @notabstract_property
+    def method(self):
+        foo()
+
+
+class Base_9(ABC):
+    @abstractproperty
+    def method(self):
+        foo()
+
+
 class MetaBase_1(metaclass=ABCMeta):  # error
    def method(self):
        foo()
--- a/resources/test/fixtures/flake8_bugbear/B027.py
+++ b/resources/test/fixtures/flake8_bugbear/B027.py
@@ -1,11 +1,12 @@
 """
 Should emit:
-B027 - on lines 12, 15, 18, 22, 30
+B027 - on lines 13, 16, 19, 23
 """
 import abc
 from abc import ABC
-from abc import abstractmethod
+from abc import abstractmethod, abstractproperty
 from abc import abstractmethod as notabstract
+from abc import abstractproperty as notabstract_property


 class AbstractClass(ABC):
@@ -42,6 +43,18 @@ class AbstractClass(ABC):
    def abstract_3(self):
        ...

+    @abc.abstractproperty
+    def abstract_4(self):
+        ...
+
+    @abstractproperty
+    def abstract_5(self):
+        ...
+
+    @notabstract_property
+    def abstract_6(self):
+        ...
+
    def body_1(self):
        print("foo")
        ...
--- a/resources/test/fixtures/flake8_comprehensions/C400.py
+++ b/resources/test/fixtures/flake8_comprehensions/C400.py
@@ -2,3 +2,10 @@ x = list(x for x in range(3))
 x = list(
    x for x in range(3)
 )
+
+
+def list(*args, **kwargs):
+    return None
+
+
+list(x for x in range(3))
--- a/resources/test/fixtures/flake8_comprehensions/C401.py
+++ b/resources/test/fixtures/flake8_comprehensions/C401.py
@@ -2,3 +2,10 @@ x = set(x for x in range(3))
 x = set(
    x for x in range(3)
 )
+
+
+def set(*args, **kwargs):
+    return None
+
+
+set(x for x in range(3))
--- a/resources/test/fixtures/flake8_comprehensions/C405.py
+++ b/resources/test/fixtures/flake8_comprehensions/C405.py
@@ -1,5 +1,18 @@
-s1 = set([1, 2])
-s2 = set((1, 2))
-s3 = set([])
-s4 = set(())
-s5 = set()
+set([1, 2])
+set((1, 2))
+set([])
+set(())
+set()
+set((1,))
+set((
+    1,
+))
+set([
+    1,
+])
+set(
+    (1,)
+)
+set(
+    [1,]
+)
--- a/resources/test/fixtures/flake8_comprehensions/C408.py
+++ b/resources/test/fixtures/flake8_comprehensions/C408.py
@@ -3,3 +3,10 @@ l = list()
 d1 = dict()
 d2 = dict(a=1)
 d3 = dict(**d2)
+
+
+def list():
+    return [1, 2, 3]
+
+
+a = list()
--- a/resources/test/fixtures/flake8_comprehensions/C413.py
+++ b/resources/test/fixtures/flake8_comprehensions/C413.py
@@ -4,3 +4,10 @@ list(sorted(x))
 reversed(sorted(x))
 reversed(sorted(x, key=lambda e: e))
 reversed(sorted(x, reverse=True))
+
+
+def reversed(*args, **kwargs):
+    return None
+
+
+reversed(sorted(x, reverse=True))
--- a/resources/test/fixtures/flake8_pie/PIE794.py
+++ b/resources/test/fixtures/flake8_pie/PIE794.py
@@ -31,3 +31,10 @@ class User(BaseModel):
    @buzz.setter
    def buzz(self, value: str | int) -> None:
        ...
+
+
+class User:
+    bar: str = StringField()
+    foo: bool = BooleanField()
+    # ...
+    bar = StringField()  # PIE794
--- a/resources/test/fixtures/flake8_quotes/docstring_doubles_function.py
+++ b/resources/test/fixtures/flake8_quotes/docstring_doubles_function.py
@@ -17,6 +17,15 @@ def fun_with_params_no_docstring(a, b="""
 """ """docstring"""):
    pass

+
 def fun_with_params_no_docstring2(a, b=c[foo():], c=\
    """ not a docstring """):
    pass
+
+
+def function_with_single_docstring(a):
+    "Single line docstring"
+
+
+def double_inside_single(a):
+    'Double inside "single "'
--- a/resources/test/fixtures/flake8_quotes/docstring_singles_function.py
+++ b/resources/test/fixtures/flake8_quotes/docstring_singles_function.py
@@ -13,11 +13,19 @@ def foo2():


 def fun_with_params_no_docstring(a, b='''
-    not a 
+    not a
 ''' '''docstring'''):
    pass

+
 def fun_with_params_no_docstring2(a, b=c[foo():], c=\
    ''' not a docstring '''):
    pass

+
+def function_with_single_docstring(a):
+    'Single line docstring'
+
+
+def double_inside_single(a):
+    "Double inside 'single '"
--- a/resources/test/fixtures/flake8_quotes/doubles_escaped.py
+++ b/resources/test/fixtures/flake8_quotes/doubles_escaped.py
@@ -1,4 +1,5 @@
 this_should_raise_Q003 = 'This is a \'string\''
+this_should_raise_Q003 = 'This is \\ a \\\'string\''
 this_is_fine = '"This" is a \'string\''
 this_is_fine = "This is a 'string'"
 this_is_fine = "\"This\" is a 'string'"
--- a/resources/test/fixtures/flake8_simplify/SIM108.py
+++ b/resources/test/fixtures/flake8_simplify/SIM108.py
@@ -1,13 +1,13 @@
-# Bad
+# SIM108
 if a:
    b = c
 else:
    b = d

-# Good
+# OK
 b = c if a else d

-# https://github.com/MartinThoma/flake8-simplify/issues/115
+# OK
 if a:
    b = c
 elif c:
@@ -15,6 +15,7 @@ elif c:
 else:
    b = d

+# OK
 if True:
    pass
 elif a:
@@ -22,6 +23,7 @@ elif a:
 else:
    b = 2

+# OK (false negative)
 if True:
    pass
 else:
@@ -29,3 +31,63 @@ else:
        b = 1
    else:
        b = 2
+
+
+import sys
+
+# OK
+if sys.version_info >= (3, 9):
+    randbytes = random.randbytes
+else:
+    randbytes = _get_random_bytes
+
+# OK
+if sys.platform == "darwin":
+    randbytes = random.randbytes
+else:
+    randbytes = _get_random_bytes
+
+# OK
+if sys.platform.startswith("linux"):
+    randbytes = random.randbytes
+else:
+    randbytes = _get_random_bytes
+
+
+# OK (includes comments)
+if x > 0:
+    # test test
+    abc = x
+else:
+    # test test test
+    abc = -x
+
+
+# OK (too long)
+if parser.errno == BAD_FIRST_LINE:
+    req = wrappers.Request(sock, server=self._server)
+else:
+    req = wrappers.Request(
+        sock,
+        parser.get_method(),
+        parser.get_scheme() or _scheme,
+        parser.get_path(),
+        parser.get_version(),
+        parser.get_query_string(),
+        server=self._server,
+    )
+
+
+# SIM108
+if a:
+    b = cccccccccccccccccccccccccccccccccccc
+else:
+    b = ddddddddddddddddddddddddddddddddddddd
+
+
+# OK (too long)
+if True:
+    if a:
+        b = cccccccccccccccccccccccccccccccccccc
+    else:
+        b = ddddddddddddddddddddddddddddddddddddd
--- a/resources/test/fixtures/flake8_simplify/SIM110.py
+++ b/resources/test/fixtures/flake8_simplify/SIM110.py
@@ -1,5 +1,6 @@
 def f():
-    for x in iterable:  # SIM110
+    # SIM110
+    for x in iterable:
        if check(x):
            return True
    return False
@@ -20,14 +21,16 @@ def f():


 def f():
-    for x in iterable:  # SIM111
+    # SIM111
+    for x in iterable:
        if check(x):
            return False
    return True


 def f():
-    for x in iterable:  # SIM111
+    # SIM111
+    for x in iterable:
        if not x.is_empty():
            return False
    return True
@@ -45,3 +48,70 @@ def f():
        if check(x):
            return "foo"
    return "bar"
+
+
+def f():
+    # SIM110
+    for x in iterable:
+        if check(x):
+            return True
+    else:
+        return False
+
+
+def f():
+    # SIM111
+    for x in iterable:
+        if check(x):
+            return False
+    else:
+        return True
+
+
+def f():
+    # SIM110
+    for x in iterable:
+        if check(x):
+            return True
+    else:
+        return False
+    return True
+
+
+def f():
+    # SIM111
+    for x in iterable:
+        if check(x):
+            return False
+    else:
+        return True
+    return False
+
+
+def f():
+    for x in iterable:
+        if check(x):
+            return True
+        elif x.is_empty():
+            return True
+    return False
+
+
+def f():
+    for x in iterable:
+        if check(x):
+            return True
+        else:
+            return True
+    return False
+
+
+def f():
+    for x in iterable:
+        if check(x):
+            return True
+        elif x.is_empty():
+            return True
+    else:
+        return True
+    return False
--- a/resources/test/fixtures/flake8_simplify/SIM111.py
+++ b/resources/test/fixtures/flake8_simplify/SIM111.py
@@ -1,10 +1,18 @@
 def f():
-    for x in iterable:  # SIM110
+    # SIM110
+    for x in iterable:
        if check(x):
            return True
    return False


+def f():
+    for x in iterable:
+        if check(x):
+            return True
+    return True
+
+
 def f():
    for el in [1, 2, 3]:
        if is_true(el):
@@ -13,21 +21,97 @@ def f():


 def f():
-    for x in iterable:  # SIM111
+    # SIM111
+    for x in iterable:
        if check(x):
            return False
    return True


 def f():
-    for x in iterable:  # SIM 111
+    # SIM111
+    for x in iterable:
        if not x.is_empty():
            return False
    return True


+def f():
+    for x in iterable:
+        if check(x):
+            return False
+    return False
+
+
 def f():
    for x in iterable:
        if check(x):
            return "foo"
    return "bar"
+
+
+def f():
+    # SIM110
+    for x in iterable:
+        if check(x):
+            return True
+    else:
+        return False
+
+
+def f():
+    # SIM111
+    for x in iterable:
+        if check(x):
+            return False
+    else:
+        return True
+
+
+def f():
+    # SIM110
+    for x in iterable:
+        if check(x):
+            return True
+    else:
+        return False
+    return True
+
+
+def f():
+    # SIM111
+    for x in iterable:
+        if check(x):
+            return False
+    else:
+        return True
+    return False
+
+
+def f():
+    for x in iterable:
+        if check(x):
+            return True
+        elif x.is_empty():
+            return True
+    return False
+
+
+def f():
+    for x in iterable:
+        if check(x):
+            return True
+        else:
+            return True
+    return False
+
+
+def f():
+    for x in iterable:
+        if check(x):
+            return True
+        elif x.is_empty():
+            return True
+    else:
+        return True
+    return False
--- a/resources/test/fixtures/flake8_simplify/SIM112.py
+++ b/resources/test/fixtures/flake8_simplify/SIM112.py
@@ -0,0 +1,19 @@
+import os
+
+# Bad
+os.environ['foo']
+
+os.environ.get('foo')
+
+os.environ.get('foo', 'bar')
+
+os.getenv('foo')
+
+# Good
+os.environ['FOO']
+
+os.environ.get('FOO')
+
+os.environ.get('FOO', 'bar')
+
+os.getenv('FOO')
--- a/resources/test/fixtures/flake8_simplify/SIM115.py
+++ b/resources/test/fixtures/flake8_simplify/SIM115.py
@@ -0,0 +1,6 @@
+f = open('foo.txt')  # SIM115
+data = f.read()
+f.close()
+
+with open('foo.txt') as f:  # OK
+    data = f.read()
--- a/resources/test/fixtures/flake8_simplify/SIM401.py
+++ b/resources/test/fixtures/flake8_simplify/SIM401.py
@@ -0,0 +1,87 @@
+###
+# Positive cases
+###
+
+# SIM401 (pattern-1)
+if key in a_dict:
+    var = a_dict[key]
+else:
+    var = "default1"
+
+# SIM401 (pattern-2)
+if key not in a_dict:
+    var = "default2"
+else:
+    var = a_dict[key]
+
+# SIM401 (default with a complex expression)
+if key in a_dict:
+    var = a_dict[key]
+else:
+    var = val1 + val2
+
+# SIM401 (complex expression in key)
+if keys[idx] in a_dict:
+    var = a_dict[keys[idx]]
+else:
+    var = "default"
+
+# SIM401 (complex expression in dict)
+if key in dicts[idx]:
+    var = dicts[idx][key]
+else:
+    var = "default"
+
+# SIM401 (complex expression in var)
+if key in a_dict:
+    vars[idx] = a_dict[key]
+else:
+    vars[idx] = "default"
+
+###
+# Negative cases
+###
+
+# OK (false negative)
+if not key in a_dict:
+    var = "default"
+else:
+    var = a_dict[key]
+
+# OK (different dict)
+if key in a_dict:
+    var = other_dict[key]
+else:
+    var = "default"
+
+# OK (different key)
+if key in a_dict:
+    var = a_dict[other_key]
+else:
+    var = "default"
+
+# OK (different var)
+if key in a_dict:
+    var = a_dict[key]
+else:
+    other_var = "default"
+
+# OK (extra vars in body)
+if key in a_dict:
+    var = a_dict[key]
+    var2 = value2
+else:
+    var = "default"
+
+# OK (extra vars in orelse)
+if key in a_dict:
+    var = a_dict[key]
+else:
+    var2 = value2
+    var = "default"
+
+# OK (complex default value)
+if key in a_dict:
+    var = a_dict[key]
+else:
+    var = foo()
--- a/resources/test/fixtures/flake8_unused_arguments/ARG.py
+++ b/resources/test/fixtures/flake8_unused_arguments/ARG.py
@@ -77,6 +77,34 @@ class C:
    def f(x):
        ...

+    def f(self, x):
+        """Docstring."""
+
+    def f(self, x):
+        """Docstring."""
+        ...
+
+    def f(self, x):
+        pass
+
+    def f(self, x):
+        raise NotImplementedError
+
+    def f(self, x):
+        raise NotImplementedError()
+
+    def f(self, x):
+        raise NotImplementedError("...")
+
+    def f(self, x):
+        raise NotImplemented
+
+    def f(self, x):
+        raise NotImplemented()
+
+    def f(self, x):
+        raise NotImplemented("...")
+
    ###
    # Unused functions attached to abstract methods (OK).
    ###
@@ -153,3 +181,17 @@ def f(a: int, b: int) -> str:

 def f(a, b):
    return f"{a}{b}"
+
+
+###
+# Unused arguments on magic methods.
+###
+class C:
+    def __init__(self, x) -> None:
+        print("Hello, world!")
+
+    def __str__(self) -> str:
+        return "Hello, world!"
+
+    def __exit__(self, exc_type, exc_value, traceback) -> None:
+        print("Hello, world!")
--- a/resources/test/fixtures/isort/force_sort_within_sections.py
+++ b/resources/test/fixtures/isort/force_sort_within_sections.py
@@ -0,0 +1,11 @@
+from a import a1  # import_from
+from c import * # import_from_star
+import a  # import
+import c.d
+import b as b1  # import_as
+
+from ..parent import *
+from .my import fn
+from . import my
+from .my.nested import fn2
+from ...grandparent import fn3
--- a/resources/test/fixtures/isort/order_by_type_with_custom_classes.py
+++ b/resources/test/fixtures/isort/order_by_type_with_custom_classes.py
@@ -0,0 +1,4 @@
+from sklearn.svm import func, SVC, CONST, Klass
+from subprocess import N_CLASS, PIPE, Popen, STDOUT
+from module import CLASS, Class, CONSTANT, function, BASIC, Apple
+from torch.nn import SELU, AClass, A_CONSTANT
--- a/resources/test/fixtures/isort/relative_imports_order.py
+++ b/resources/test/fixtures/isort/relative_imports_order.py
@@ -0,0 +1,3 @@
+from ... import a
+from .. import b
+from . import c
--- a/resources/test/fixtures/isort/required_imports/comment.py
+++ b/resources/test/fixtures/isort/required_imports/comment.py
@@ -0,0 +1,3 @@
+#!/usr/bin/env python3
+
+x = 1
--- a/resources/test/fixtures/isort/required_imports/docstring.py
+++ b/resources/test/fixtures/isort/required_imports/docstring.py
@@ -0,0 +1,3 @@
+"""Hello, world!"""
+
+x = 1
--- a/resources/test/fixtures/isort/required_imports/docstring_only.py
+++ b/resources/test/fixtures/isort/required_imports/docstring_only.py
@@ -0,0 +1 @@
+"""Hello, world!"""
--- a/resources/test/fixtures/isort/required_imports/docstring_with_continuation.py
+++ b/resources/test/fixtures/isort/required_imports/docstring_with_continuation.py
@@ -0,0 +1,2 @@
+"""Hello, world!"""; x = \
+    1; y = 2
--- a/resources/test/fixtures/isort/required_imports/docstring_with_semicolon.py
+++ b/resources/test/fixtures/isort/required_imports/docstring_with_semicolon.py
@@ -0,0 +1 @@
+"""Hello, world!"""; x = 1
--- a/resources/test/fixtures/isort/required_imports/empty.py
+++ b/resources/test/fixtures/isort/required_imports/empty.py
--- a/resources/test/fixtures/isort/required_imports/existing_import.py
+++ b/resources/test/fixtures/isort/required_imports/existing_import.py
@@ -0,0 +1,2 @@
+from __future__ import generator_stop
+import os
--- a/resources/test/fixtures/pycodestyle/W505.py
+++ b/resources/test/fixtures/pycodestyle/W505.py
@@ -0,0 +1,15 @@
+#!/usr/bin/env python3
+"""Here's a top-level docstring that's over the limit."""
+
+
+def f():
+    """Here's a docstring that's also over the limit."""
+
+    x = 1  # Here's a comment that's over the limit, but it's not standalone.
+
+    # Here's a standalone comment that's over the limit.
+
+    print("Here's a string that's over the limit, but it's not a docstring.")
+
+
+"This is also considered a docstring, and is over the limit."
--- a/resources/test/fixtures/pyflakes/F401_6.py
+++ b/resources/test/fixtures/pyflakes/F401_6.py
@@ -9,7 +9,6 @@ from .background import BackgroundTasks
 # F401 `datastructures.UploadFile` imported but unused
 from .datastructures import UploadFile as FileUpload

-
 # OK
 import applications as applications

--- a/resources/test/fixtures/pyflakes/builtins.py
+++ b/resources/test/fixtures/pyflakes/builtins.py
@@ -0,0 +1 @@
+_("Translations")
--- a/resources/test/fixtures/pyflakes/typing_modules.py
+++ b/resources/test/fixtures/pyflakes/typing_modules.py
@@ -0,0 +1,7 @@
+from typing import Union
+
+from airflow.typing_compat import Literal, Optional
+
+
+X = Union[Literal[False], Literal["db"]]
+y = Optional["Class"]
--- a/resources/test/fixtures/pygrep-hooks/PGH002_0.py
+++ b/resources/test/fixtures/pygrep-hooks/PGH002_0.py
@@ -5,4 +5,3 @@ from warnings import warn
 warnings.warn("this is ok")
 warn("by itself is also ok")
 logging.warning("this is fine")
-log.warning("this is ok")
--- a/resources/test/fixtures/pygrep-hooks/PGH002_1.py
+++ b/resources/test/fixtures/pygrep-hooks/PGH002_1.py
@@ -2,14 +2,4 @@ import logging
 from logging import warn

 logging.warn("this is not ok")
-log.warn("this is also not ok")
 warn("not ok")
-
-
-def foo():
-    from logging import warn
-
-    def warn():
-        pass
-
-    warn("has been redefined, but we will still report it")
--- a/resources/test/fixtures/pylint/constant_comparison.py
+++ b/resources/test/fixtures/pylint/constant_comparison.py
@@ -0,0 +1,59 @@
+"""Check that magic values are not used in comparisons"""
+
+if 100 == 100: # [comparison-of-constants]
+    pass
+
+if 1 == 3: # [comparison-of-constants]
+    pass
+
+if 1 != 3: # [comparison-of-constants]
+    pass
+
+x = 0
+if 4 == 3 == x: # [comparison-of-constants]
+    pass
+
+if x == 0: # correct
+    pass
+
+y = 1
+if x == y: # correct
+    pass
+
+if 1 > 0: # [comparison-of-constants]
+    pass
+
+if x > 0: # correct
+    pass
+
+if 1 >= 0: # [comparison-of-constants]
+    pass
+
+if x >= 0: # correct
+    pass
+
+if 1 < 0: # [comparison-of-constants]
+    pass
+
+if x < 0: # correct
+    pass
+
+if 1 <= 0: # [comparison-of-constants]
+    pass
+
+if x <= 0: # correct
+    pass
+
+word = "hello"
+if word == "": # correct
+    pass
+
+if "hello" == "": # [comparison-of-constants]
+    pass
+
+truthy = True
+if truthy == True: # correct
+    pass
+
+if True == False: # [comparison-of-constants]
+    pass
--- a/resources/test/fixtures/pylint/magic_value_comparison.py
+++ b/resources/test/fixtures/pylint/magic_value_comparison.py
@@ -0,0 +1,71 @@
+"""Check that magic values are not used in comparisons"""
+import cmath
+
+user_input = 10
+
+if 10 > user_input: # [magic-value-comparison]
+    pass
+
+if 10 == 100: # [comparison-of-constants] R0133
+    pass
+
+if 1 == 3: # [comparison-of-constants] R0133
+    pass
+
+x = 0
+if 4 == 3 == x: # [comparison-of-constants] R0133
+    pass
+
+time_delta = 7224
+ONE_HOUR = 3600
+
+if time_delta > ONE_HOUR: # correct
+    pass
+
+argc = 1
+
+if argc != -1: # correct
+    pass
+
+if argc != 0: # correct
+    pass
+
+if argc != 1: # correct
+    pass
+
+if argc != 2: # [magic-value-comparison]
+    pass
+
+if __name__ == "__main__": # correct
+    pass
+
+ADMIN_PASSWORD = "SUPERSECRET"
+input_password = "password"
+
+if input_password == "": # correct
+    pass
+
+if input_password == ADMIN_PASSWORD: # correct
+    pass
+
+if input_password == "Hunter2": # [magic-value-comparison]
+    pass
+
+PI = 3.141592653589793238
+pi_estimation = 3.14
+
+if pi_estimation == 3.141592653589793238: # [magic-value-comparison]
+    pass
+
+if pi_estimation == PI: # correct
+    pass
+
+HELLO_WORLD = b"Hello, World!"
+user_input = b"Hello, There!"
+
+if user_input == b"something": # [magic-value-comparison]
+    pass
+
+if user_input == HELLO_WORLD: # correct
+    pass
+
--- a/resources/test/fixtures/pyupgrade/UP024_3.py
+++ b/resources/test/fixtures/pyupgrade/UP024_3.py
@@ -0,0 +1,8 @@
+class SocketError(Exception):
+    pass
+
+
+try:
+    raise SocketError()
+except SocketError:
+    pass
--- a/resources/test/fixtures/pyupgrade/UP030_0.py
+++ b/resources/test/fixtures/pyupgrade/UP030_0.py
@@ -0,0 +1,36 @@
+# Invalid calls; errors expected.
+
+"{0}" "{1}" "{2}".format(1, 2, 3)
+
+"a {3} complicated {1} string with {0} {2}".format(
+    "first", "second", "third", "fourth"
+)
+
+'{0}'.format(1)
+
+'{0:x}'.format(30)
+
+x = '{0}'.format(1)
+
+'''{0}\n{1}\n'''.format(1, 2)
+
+x = "foo {0}" \
+    "bar {1}".format(1, 2)
+
+("{0}").format(1)
+
+"\N{snowman} {0}".format(1)
+
+'{' '0}'.format(1)
+
+# These will not change because we are waiting for libcst to fix this issue:
+# https://github.com/Instagram/LibCST/issues/846
+print(
+    'foo{0}'
+    'bar{1}'.format(1, 2)
+)
+
+print(
+    'foo{0}'  # ohai\n"
+    'bar{1}'.format(1, 2)
+)
--- a/resources/test/fixtures/pyupgrade/UP030_1.py
+++ b/resources/test/fixtures/pyupgrade/UP030_1.py
@@ -0,0 +1,23 @@
+# Valid calls; no errors expected.
+
+'{}'.format(1)
+
+
+x = ('{0} {1}',)
+
+'{0} {0}'.format(1)
+
+'{0:<{1}}'.format(1, 4)
+
+f"{0}".format(a)
+
+f"{0}".format(1)
+
+print(f"{0}".format(1))
+
+# I did not include the following tests because ruff does not seem to work with
+# invalid python syntax (which is a good thing)
+
+# "{0}"format(1)
+# '{'.format(1)", "'}'.format(1)
+# ("{0}" # {1}\n"{2}").format(1, 2, 3)
--- a/resources/test/project/README.md
+++ b/resources/test/project/README.md
@@ -17,7 +17,7 @@ resources/test/project/examples/docs/docs/file.py:8:5: F841 Local variable `x` i
 resources/test/project/project/file.py:1:8: F401 `os` imported but unused
 resources/test/project/project/import_file.py:1:1: I001 Import block is un-sorted or un-formatted
 Found 7 error(s).
-6 potentially fixable with the --fix option.
+7 potentially fixable with the --fix option.
 ```

 Running from the project directory itself should exhibit the same behavior:
@@ -32,7 +32,7 @@ examples/docs/docs/file.py:8:5: F841 Local variable `x` is assigned to but never
 project/file.py:1:8: F401 `os` imported but unused
 project/import_file.py:1:1: I001 Import block is un-sorted or un-formatted
 Found 7 error(s).
-6 potentially fixable with the --fix option.
+7 potentially fixable with the --fix option.
 ```

 Running from the sub-package directory should exhibit the same behavior, but omit the top-level
@@ -43,7 +43,7 @@ files:
 docs/file.py:1:1: I001 Import block is un-sorted or un-formatted
 docs/file.py:8:5: F841 Local variable `x` is assigned to but never used
 Found 2 error(s).
-1 potentially fixable with the --fix option.
+2 potentially fixable with the --fix option.
 ```

 `--config` should force Ruff to use the specified `pyproject.toml` for all files, and resolve
@@ -74,7 +74,7 @@ docs/docs/file.py:1:1: I001 Import block is un-sorted or un-formatted
 docs/docs/file.py:8:5: F841 Local variable `x` is assigned to but never used
 excluded/script.py:5:5: F841 Local variable `x` is assigned to but never used
 Found 4 error(s).
-1 potentially fixable with the --fix option.
+4 potentially fixable with the --fix option.
 ```

 Passing an excluded directory directly should report errors in the contained files:
--- a/ruff.schema.json
+++ b/ruff.schema.json
--- a/ruff_cli/Cargo.toml
+++ b/ruff_cli/Cargo.toml
@@ -0,0 +1,62 @@
+[package]
+name = "ruff_cli"
+version = "0.0.221"
+authors = ["Charlie Marsh <charlie.r.marsh@gmail.com>"]
+edition = "2021"
+rust-version = "1.65.0"
+documentation = "https://github.com/charliermarsh/ruff"
+homepage = "https://github.com/charliermarsh/ruff"
+repository = "https://github.com/charliermarsh/ruff"
+readme = "../README.md"
+license = "MIT"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[[bin]]
+name = "ruff"
+path = "src/main.rs"
+doctest = false
+
+[dependencies]
+ruff = { path = ".." }
+
+annotate-snippets = { version = "0.9.1", features = ["color"] }
+anyhow = { version = "1.0.66" }
+atty = { version = "0.2.14" }
+bincode = { version = "1.3.3" }
+cachedir = { version = "0.3.0" }
+chrono = { version = "0.4.21", default-features = false, features = ["clock"] }
+clap = { version = "4.0.1", features = ["derive", "env"] }
+clap_complete_command = { version = "0.4.0" }
+clearscreen = { version = "2.0.0" }
+colored = { version = "2.0.0" }
+filetime = { version = "0.2.17" }
+glob = { version = "0.3.0" }
+ignore = { version = "0.4.18" }
+itertools = { version = "0.10.5" }
+log = { version = "0.4.17" }
+notify = { version = "5.0.0" }
+path-absolutize = { version = "3.0.14", features = ["once_cell_cache"] }
+quick-junit = { version = "0.3.2" }
+rayon = { version = "1.5.3" }
+regex = { version = "1.6.0" }
+rustc-hash = { version = "1.1.0" }
+serde = { version = "1.0.147", features = ["derive"] }
+serde_json = { version = "1.0.87" }
+similar = { version = "2.2.1" }
+textwrap = { version = "0.16.0" }
+update-informer = { version = "0.6.0", default-features = false, features = ["pypi"], optional = true }
+walkdir = { version = "2.3.2" }
+
+[dev-dependencies]
+assert_cmd = { version = "2.0.4" }
+strum = { version = "0.24.1" }
+ureq = { version = "2.5.0", features = [] }
+
+[features]
+default = ["update-informer"]
+update-informer = ["dep:update-informer"]
+
+[package.metadata.maturin]
+name = "ruff"
+# Setting the name here is necessary for maturin to include the package in its builds.
--- a/ruff_cli/src/cache.rs
+++ b/ruff_cli/src/cache.rs
@@ -0,0 +1,124 @@
+use std::collections::hash_map::DefaultHasher;
+use std::fs;
+use std::hash::{Hash, Hasher};
+use std::io::Write;
+use std::path::Path;
+
+use anyhow::Result;
+use filetime::FileTime;
+use log::error;
+use path_absolutize::Absolutize;
+use ruff::message::Message;
+use ruff::settings::{flags, Settings};
+use serde::{Deserialize, Serialize};
+
+const CARGO_PKG_VERSION: &str = env!("CARGO_PKG_VERSION");
+
+#[derive(Serialize, Deserialize)]
+struct CacheMetadata {
+    mtime: i64,
+}
+
+#[derive(Serialize)]
+struct CheckResultRef<'a> {
+    metadata: &'a CacheMetadata,
+    messages: &'a [Message],
+}
+
+#[derive(Deserialize)]
+struct CheckResult {
+    metadata: CacheMetadata,
+    messages: Vec<Message>,
+}
+
+fn content_dir() -> &'static Path {
+    Path::new("content")
+}
+
+fn cache_key<P: AsRef<Path>>(path: P, settings: &Settings, autofix: flags::Autofix) -> u64 {
+    let mut hasher = DefaultHasher::new();
+    CARGO_PKG_VERSION.hash(&mut hasher);
+    path.as_ref().absolutize().unwrap().hash(&mut hasher);
+    settings.hash(&mut hasher);
+    autofix.hash(&mut hasher);
+    hasher.finish()
+}
+
+#[allow(dead_code)]
+/// Initialize the cache at the specified `Path`.
+pub fn init(path: &Path) -> Result<()> {
+    // Create the cache directories.
+    fs::create_dir_all(path.join(content_dir()))?;
+
+    // Add the CACHEDIR.TAG.
+    if !cachedir::is_tagged(path)? {
+        cachedir::add_tag(path)?;
+    }
+
+    // Add the .gitignore.
+    let gitignore_path = path.join(".gitignore");
+    if !gitignore_path.exists() {
+        let mut file = fs::File::create(gitignore_path)?;
+        file.write_all(b"*")?;
+    }
+
+    Ok(())
+}
+
+fn write_sync(cache_dir: &Path, key: u64, value: &[u8]) -> Result<(), std::io::Error> {
+    fs::write(
+        cache_dir.join(content_dir()).join(format!("{key:x}")),
+        value,
+    )
+}
+
+fn read_sync(cache_dir: &Path, key: u64) -> Result<Vec<u8>, std::io::Error> {
+    fs::read(cache_dir.join(content_dir()).join(format!("{key:x}")))
+}
+
+/// Get a value from the cache.
+pub fn get<P: AsRef<Path>>(
+    path: P,
+    metadata: &fs::Metadata,
+    settings: &Settings,
+    autofix: flags::Autofix,
+) -> Option<Vec<Message>> {
+    let encoded = read_sync(&settings.cache_dir, cache_key(path, settings, autofix)).ok()?;
+    let (mtime, messages) = match bincode::deserialize::<CheckResult>(&encoded[..]) {
+        Ok(CheckResult {
+            metadata: CacheMetadata { mtime },
+            messages,
+        }) => (mtime, messages),
+        Err(e) => {
+            error!("Failed to deserialize encoded cache entry: {e:?}");
+            return None;
+        }
+    };
+    if FileTime::from_last_modification_time(metadata).unix_seconds() != mtime {
+        return None;
+    }
+    Some(messages)
+}
+
+/// Set a value in the cache.
+pub fn set<P: AsRef<Path>>(
+    path: P,
+    metadata: &fs::Metadata,
+    settings: &Settings,
+    autofix: flags::Autofix,
+    messages: &[Message],
+) {
+    let check_result = CheckResultRef {
+        metadata: &CacheMetadata {
+            mtime: FileTime::from_last_modification_time(metadata).unix_seconds(),
+        },
+        messages,
+    };
+    if let Err(e) = write_sync(
+        &settings.cache_dir,
+        cache_key(path, settings, autofix),
+        &bincode::serialize(&check_result).unwrap(),
+    ) {
+        error!("Failed to write to cache: {e:?}");
+    }
+}
--- a/ruff_cli/src/cli.rs
+++ b/ruff_cli/src/cli.rs
@@ -2,17 +2,21 @@ use std::path::{Path, PathBuf};

 use clap::{command, Parser};
 use regex::Regex;
-use rustc_hash::FxHashMap;
-
-use crate::fs;
-use crate::logging::LogLevel;
-use crate::registry::{CheckCode, CheckCodePrefix};
-use crate::settings::types::{
+use ruff::logging::LogLevel;
+use ruff::registry::{RuleCode, RuleCodePrefix};
+use ruff::resolver::ConfigProcessor;
+use ruff::settings::types::{
    FilePattern, PatternPrefixPair, PerFileIgnore, PythonVersion, SerializationFormat,
 };
+use ruff::{fs, mccabe};
+use rustc_hash::FxHashMap;

 #[derive(Debug, Parser)]
-#[command(author, about = "Ruff: An extremely fast Python linter.")]
+#[command(
+    author,
+    name = "ruff",
+    about = "Ruff: An extremely fast Python linter."
+)]
 #[command(version)]
 #[allow(clippy::struct_excessive_bools)]
 pub struct Cli {
@@ -25,26 +29,26 @@ pub struct Cli {
    /// Enable verbose logging.
    #[arg(short, long, group = "verbosity")]
    pub verbose: bool,
-    /// Only log errors.
+    /// Print lint violations, but nothing else.
    #[arg(short, long, group = "verbosity")]
    pub quiet: bool,
    /// Disable all logging (but still exit with status code "1" upon detecting
-    /// errors).
+    /// lint violations).
    #[arg(short, long, group = "verbosity")]
    pub silent: bool,
-    /// Exit with status code "0", even upon detecting errors.
+    /// Exit with status code "0", even upon detecting lint violations.
    #[arg(short, long)]
    pub exit_zero: bool,
    /// Run in watch mode by re-running whenever files change.
    #[arg(short, long)]
    pub watch: bool,
-    /// Attempt to automatically fix lint errors.
+    /// Attempt to automatically fix lint violations.
    #[arg(long, overrides_with("no_fix"))]
    fix: bool,
    #[clap(long, overrides_with("fix"), hide = true)]
    no_fix: bool,
-    /// Fix any fixable lint errors, but don't report on leftover violations.
-    /// Implies `--fix`.
+    /// Fix any fixable lint violations, but don't report on leftover
+    /// violations. Implies `--fix`.
    #[arg(long, overrides_with("no_fix_only"))]
    fix_only: bool,
    #[clap(long, overrides_with("fix_only"), hide = true)]
@@ -59,40 +63,40 @@ pub struct Cli {
    /// Ignore all configuration files.
    #[arg(long, conflicts_with = "config")]
    pub isolated: bool,
-    /// Comma-separated list of error codes to enable (or ALL, to enable all
-    /// checks).
-    #[arg(long, value_delimiter = ',')]
-    pub select: Option<Vec<CheckCodePrefix>>,
-    /// Like --select, but adds additional error codes on top of the selected
+    /// Comma-separated list of rule codes to enable (or ALL, to enable all
+    /// rules).
+    #[arg(long, value_delimiter = ',', value_name = "RULE_CODE")]
+    pub select: Option<Vec<RuleCodePrefix>>,
+    /// Like --select, but adds additional rule codes on top of the selected
    /// ones.
-    #[arg(long, value_delimiter = ',')]
-    pub extend_select: Option<Vec<CheckCodePrefix>>,
-    /// Comma-separated list of error codes to disable.
-    #[arg(long, value_delimiter = ',')]
-    pub ignore: Option<Vec<CheckCodePrefix>>,
-    /// Like --ignore, but adds additional error codes on top of the ignored
+    #[arg(long, value_delimiter = ',', value_name = "RULE_CODE")]
+    pub extend_select: Option<Vec<RuleCodePrefix>>,
+    /// Comma-separated list of rule codes to disable.
+    #[arg(long, value_delimiter = ',', value_name = "RULE_CODE")]
+    pub ignore: Option<Vec<RuleCodePrefix>>,
+    /// Like --ignore, but adds additional rule codes on top of the ignored
    /// ones.
-    #[arg(long, value_delimiter = ',')]
-    pub extend_ignore: Option<Vec<CheckCodePrefix>>,
-    /// List of paths, used to exclude files and/or directories from checks.
-    #[arg(long, value_delimiter = ',')]
+    #[arg(long, value_delimiter = ',', value_name = "RULE_CODE")]
+    pub extend_ignore: Option<Vec<RuleCodePrefix>>,
+    /// List of paths, used to omit files and/or directories from analysis.
+    #[arg(long, value_delimiter = ',', value_name = "FILE_PATTERN")]
    pub exclude: Option<Vec<FilePattern>>,
-    /// Like --exclude, but adds additional files and directories on top of the
-    /// excluded ones.
-    #[arg(long, value_delimiter = ',')]
+    /// Like --exclude, but adds additional files and directories on top of
+    /// those already excluded.
+    #[arg(long, value_delimiter = ',', value_name = "FILE_PATTERN")]
    pub extend_exclude: Option<Vec<FilePattern>>,
-    /// List of error codes to treat as eligible for autofix. Only applicable
+    /// List of rule codes to treat as eligible for autofix. Only applicable
    /// when autofix itself is enabled (e.g., via `--fix`).
-    #[arg(long, value_delimiter = ',')]
-    pub fixable: Option<Vec<CheckCodePrefix>>,
-    /// List of error codes to treat as ineligible for autofix. Only applicable
+    #[arg(long, value_delimiter = ',', value_name = "RULE_CODE")]
+    pub fixable: Option<Vec<RuleCodePrefix>>,
+    /// List of rule codes to treat as ineligible for autofix. Only applicable
    /// when autofix itself is enabled (e.g., via `--fix`).
-    #[arg(long, value_delimiter = ',')]
-    pub unfixable: Option<Vec<CheckCodePrefix>>,
+    #[arg(long, value_delimiter = ',', value_name = "RULE_CODE")]
+    pub unfixable: Option<Vec<RuleCodePrefix>>,
    /// List of mappings from file pattern to code to exclude
    #[arg(long, value_delimiter = ',')]
    pub per_file_ignores: Option<Vec<PatternPrefixPair>>,
-    /// Output serialization format for error messages.
+    /// Output serialization format for violations.
    #[arg(long, value_enum, env = "RUFF_FORMAT")]
    pub format: Option<SerializationFormat>,
    /// The name of the file when passing it through stdin.
@@ -129,7 +133,7 @@ pub struct Cli {
    /// The minimum Python version that should be supported.
    #[arg(long)]
    pub target_version: Option<PythonVersion>,
-    /// Set the line-length for length-associated checks and automatic
+    /// Set the line-length for length-associated rules and automatic
    /// formatting.
    #[arg(long)]
    pub line_length: Option<usize>,
@@ -179,7 +183,7 @@ pub struct Cli {
        conflicts_with = "stdin_filename",
        conflicts_with = "watch",
    )]
-    pub explain: Option<CheckCode>,
+    pub explain: Option<RuleCode>,
    /// Generate shell completion
    #[arg(
        long,
@@ -212,7 +216,7 @@ pub struct Cli {
        conflicts_with = "watch",
    )]
    pub show_files: bool,
-    /// See the settings Ruff will use to check a given Python file.
+    /// See the settings Ruff will use to lint a given Python file.
    #[arg(
        long,
        // Fake subcommands.
@@ -302,7 +306,7 @@ pub struct Arguments {
    pub config: Option<PathBuf>,
    pub diff: bool,
    pub exit_zero: bool,
-    pub explain: Option<CheckCode>,
+    pub explain: Option<RuleCode>,
    pub files: Vec<PathBuf>,
    pub generate_shell_completion: Option<clap_complete_command::Shell>,
    pub isolated: bool,
@@ -323,18 +327,18 @@ pub struct Overrides {
    pub dummy_variable_rgx: Option<Regex>,
    pub exclude: Option<Vec<FilePattern>>,
    pub extend_exclude: Option<Vec<FilePattern>>,
-    pub extend_ignore: Option<Vec<CheckCodePrefix>>,
-    pub extend_select: Option<Vec<CheckCodePrefix>>,
-    pub fixable: Option<Vec<CheckCodePrefix>>,
-    pub ignore: Option<Vec<CheckCodePrefix>>,
+    pub extend_ignore: Option<Vec<RuleCodePrefix>>,
+    pub extend_select: Option<Vec<RuleCodePrefix>>,
+    pub fixable: Option<Vec<RuleCodePrefix>>,
+    pub ignore: Option<Vec<RuleCodePrefix>>,
    pub line_length: Option<usize>,
    pub max_complexity: Option<usize>,
    pub per_file_ignores: Option<Vec<PatternPrefixPair>>,
    pub respect_gitignore: Option<bool>,
-    pub select: Option<Vec<CheckCodePrefix>>,
+    pub select: Option<Vec<RuleCodePrefix>>,
    pub show_source: Option<bool>,
    pub target_version: Option<PythonVersion>,
-    pub unfixable: Option<Vec<CheckCodePrefix>>,
+    pub unfixable: Option<Vec<RuleCodePrefix>>,
    // TODO(charlie): Captured in pyproject.toml as a default, but not part of `Settings`.
    pub cache_dir: Option<PathBuf>,
    pub fix: Option<bool>,
@@ -344,6 +348,87 @@ pub struct Overrides {
    pub update_check: Option<bool>,
 }

+impl ConfigProcessor for &Overrides {
+    fn process_config(&self, config: &mut ruff::settings::configuration::Configuration) {
+        if let Some(cache_dir) = &self.cache_dir {
+            config.cache_dir = Some(cache_dir.clone());
+        }
+        if let Some(dummy_variable_rgx) = &self.dummy_variable_rgx {
+            config.dummy_variable_rgx = Some(dummy_variable_rgx.clone());
+        }
+        if let Some(exclude) = &self.exclude {
+            config.exclude = Some(exclude.clone());
+        }
+        if let Some(extend_exclude) = &self.extend_exclude {
+            config.extend_exclude.extend(extend_exclude.clone());
+        }
+        if let Some(fix) = &self.fix {
+            config.fix = Some(*fix);
+        }
+        if let Some(fix_only) = &self.fix_only {
+            config.fix_only = Some(*fix_only);
+        }
+        if let Some(fixable) = &self.fixable {
+            config.fixable = Some(fixable.clone());
+        }
+        if let Some(format) = &self.format {
+            config.format = Some(*format);
+        }
+        if let Some(force_exclude) = &self.force_exclude {
+            config.force_exclude = Some(*force_exclude);
+        }
+        if let Some(ignore) = &self.ignore {
+            config.ignore = Some(ignore.clone());
+        }
+        if let Some(line_length) = &self.line_length {
+            config.line_length = Some(*line_length);
+        }
+        if let Some(max_complexity) = &self.max_complexity {
+            config.mccabe = Some(mccabe::settings::Options {
+                max_complexity: Some(*max_complexity),
+            });
+        }
+        if let Some(per_file_ignores) = &self.per_file_ignores {
+            config.per_file_ignores = Some(collect_per_file_ignores(per_file_ignores.clone()));
+        }
+        if let Some(respect_gitignore) = &self.respect_gitignore {
+            config.respect_gitignore = Some(*respect_gitignore);
+        }
+        if let Some(select) = &self.select {
+            config.select = Some(select.clone());
+        }
+        if let Some(show_source) = &self.show_source {
+            config.show_source = Some(*show_source);
+        }
+        if let Some(target_version) = &self.target_version {
+            config.target_version = Some(*target_version);
+        }
+        if let Some(unfixable) = &self.unfixable {
+            config.unfixable = Some(unfixable.clone());
+        }
+        if let Some(update_check) = &self.update_check {
+            config.update_check = Some(*update_check);
+        }
+        // Special-case: `extend_ignore` and `extend_select` are parallel arrays, so
+        // push an empty array if only one of the two is provided.
+        match (&self.extend_ignore, &self.extend_select) {
+            (Some(extend_ignore), Some(extend_select)) => {
+                config.extend_ignore.push(extend_ignore.clone());
+                config.extend_select.push(extend_select.clone());
+            }
+            (Some(extend_ignore), None) => {
+                config.extend_ignore.push(extend_ignore.clone());
+                config.extend_select.push(Vec::new());
+            }
+            (None, Some(extend_select)) => {
+                config.extend_ignore.push(Vec::new());
+                config.extend_select.push(extend_select.clone());
+            }
+            (None, None) => {}
+        }
+    }
+}
+
 /// Map the CLI settings to a `LogLevel`.
 pub fn extract_log_level(cli: &Arguments) -> LogLevel {
    if cli.silent {
@@ -359,7 +444,7 @@ pub fn extract_log_level(cli: &Arguments) -> LogLevel {

 /// Convert a list of `PatternPrefixPair` structs to `PerFileIgnore`.
 pub fn collect_per_file_ignores(pairs: Vec<PatternPrefixPair>) -> Vec<PerFileIgnore> {
-    let mut per_file_ignores: FxHashMap<String, Vec<CheckCodePrefix>> = FxHashMap::default();
+    let mut per_file_ignores: FxHashMap<String, Vec<RuleCodePrefix>> = FxHashMap::default();
    for pair in pairs {
        per_file_ignores
            .entry(pair.pattern)
--- a/ruff_cli/src/commands.rs
+++ b/ruff_cli/src/commands.rs
@@ -11,22 +11,22 @@ use log::{debug, error};
 use path_absolutize::path_dedot;
 #[cfg(not(target_family = "wasm"))]
 use rayon::prelude::*;
-use rustpython_ast::Location;
+use ruff::cache::CACHE_DIR_NAME;
+use ruff::linter::add_noqa_to_path;
+use ruff::logging::LogLevel;
+use ruff::message::{Location, Message};
+use ruff::registry::RuleCode;
+use ruff::resolver::{FileDiscovery, PyprojectDiscovery};
+use ruff::settings::flags;
+use ruff::settings::types::SerializationFormat;
+use ruff::{fix, fs, packaging, resolver, violations, warn_user_once};
 use serde::Serialize;
 use walkdir::WalkDir;

-use crate::autofix::fixer;
-use crate::cache::CACHE_DIR_NAME;
+use crate::cache;
 use crate::cli::Overrides;
+use crate::diagnostics::{lint_path, lint_stdin, Diagnostics};
 use crate::iterators::par_iter;
-use crate::linter::{add_noqa_to_path, lint_path, lint_stdin, Diagnostics};
-use crate::logging::LogLevel;
-use crate::message::Message;
-use crate::registry::CheckCode;
-use crate::resolver::{FileDiscovery, PyprojectDiscovery};
-use crate::settings::flags;
-use crate::settings::types::SerializationFormat;
-use crate::{cache, fs, one_time_warning, packages, resolver, violations};

 /// Run the linter over a collection of files.
 pub fn run(
@@ -35,7 +35,7 @@ pub fn run(
    file_strategy: &FileDiscovery,
    overrides: &Overrides,
    cache: flags::Cache,
-    autofix: fixer::Mode,
+    autofix: fix::FixMode,
 ) -> Result<Diagnostics> {
    // Collect all the Python files to check.
    let start = Instant::now();
@@ -45,12 +45,7 @@ pub fn run(
    debug!("Identified files to lint in: {:?}", duration);

    if paths.is_empty() {
-        one_time_warning!(
-            "{}{} {}",
-            "warning".yellow().bold(),
-            ":".bold(),
-            "No Python files found under the given path(s)".bold()
-        );
+        warn_user_once!("No Python files found under the given path(s)");
        return Ok(Diagnostics::default());
    }

@@ -82,7 +77,7 @@ pub fn run(
    };

    // Discover the package root for each Python file.
-    let package_roots = packages::detect_package_roots(
+    let package_roots = packaging::detect_package_roots(
        &paths
            .iter()
            .flatten()
@@ -117,7 +112,7 @@ pub fn run(
            .unwrap_or_else(|(path, message)| {
                if let Some(path) = &path {
                    let settings = resolver.resolve(path, pyproject_strategy);
-                    if settings.enabled.contains(&CheckCode::E902) {
+                    if settings.enabled.contains(&RuleCode::E902) {
                        Diagnostics::new(vec![Message {
                            kind: violations::IOError(message).into(),
                            location: Location::default(),
@@ -161,7 +156,7 @@ pub fn run_stdin(
    pyproject_strategy: &PyprojectDiscovery,
    file_strategy: &FileDiscovery,
    overrides: &Overrides,
-    autofix: fixer::Mode,
+    autofix: fix::FixMode,
 ) -> Result<Diagnostics> {
    if let Some(filename) = filename {
        if !resolver::python_file_at_path(filename, pyproject_strategy, file_strategy, overrides)? {
@@ -174,7 +169,7 @@ pub fn run_stdin(
    };
    let package_root = filename
        .and_then(Path::parent)
-        .and_then(packages::detect_package_root);
+        .and_then(packaging::detect_package_root);
    let stdin = read_from_stdin()?;
    let mut diagnostics = lint_stdin(filename, package_root, &stdin, settings, autofix)?;
    diagnostics.messages.sort_unstable();
@@ -196,12 +191,7 @@ pub fn add_noqa(
    debug!("Identified files to lint in: {:?}", duration);

    if paths.is_empty() {
-        one_time_warning!(
-            "{}{} {}",
-            "warning".yellow().bold(),
-            ":".bold(),
-            "No Python files found under the given path(s)".bold()
-        );
+        warn_user_once!("No Python files found under the given path(s)");
        return Ok(0);
    }

@@ -271,12 +261,7 @@ pub fn show_files(
        resolver::python_files_in_path(files, pyproject_strategy, file_strategy, overrides)?;

    if paths.is_empty() {
-        one_time_warning!(
-            "{}{} {}",
-            "warning".yellow().bold(),
-            ":".bold(),
-            "No Python files found under the given path(s)".bold()
-        );
+        warn_user_once!("No Python files found under the given path(s)");
        return Ok(());
    }

@@ -298,18 +283,18 @@ pub fn show_files(
 #[derive(Serialize)]
 struct Explanation<'a> {
    code: &'a str,
-    category: &'a str,
+    origin: &'a str,
    summary: &'a str,
 }

-/// Explain a `CheckCode` to the user.
-pub fn explain(code: &CheckCode, format: &SerializationFormat) -> Result<()> {
+/// Explain a `RuleCode` to the user.
+pub fn explain(code: &RuleCode, format: SerializationFormat) -> Result<()> {
    match format {
        SerializationFormat::Text | SerializationFormat::Grouped => {
            println!(
                "{} ({}): {}",
                code.as_ref(),
-                code.category().title(),
+                code.origin().title(),
                code.kind().summary()
            );
        }
@@ -318,7 +303,7 @@ pub fn explain(code: &CheckCode, format: &SerializationFormat) -> Result<()> {
                "{}",
                serde_json::to_string_pretty(&Explanation {
                    code: code.as_ref(),
-                    category: code.category().title(),
+                    origin: code.origin().title(),
                    summary: &code.kind().summary(),
                })?
            );
--- a/ruff_cli/src/diagnostics.rs
+++ b/ruff_cli/src/diagnostics.rs
@@ -0,0 +1,155 @@
+#![cfg_attr(target_family = "wasm", allow(dead_code))]
+use std::fs::write;
+use std::io;
+use std::io::Write;
+use std::ops::AddAssign;
+use std::path::Path;
+
+use anyhow::Result;
+use log::debug;
+use ruff::linter::{lint_fix, lint_only};
+use ruff::message::Message;
+use ruff::settings::{flags, Settings};
+use ruff::{fix, fs};
+use similar::TextDiff;
+
+use crate::cache;
+
+#[derive(Debug, Default)]
+pub struct Diagnostics {
+    pub messages: Vec<Message>,
+    pub fixed: usize,
+}
+
+impl Diagnostics {
+    pub fn new(messages: Vec<Message>) -> Self {
+        Self { messages, fixed: 0 }
+    }
+}
+
+impl AddAssign for Diagnostics {
+    fn add_assign(&mut self, other: Self) {
+        self.messages.extend(other.messages);
+        self.fixed += other.fixed;
+    }
+}
+
+/// Lint the source code at the given `Path`.
+pub fn lint_path(
+    path: &Path,
+    package: Option<&Path>,
+    settings: &Settings,
+    cache: flags::Cache,
+    autofix: fix::FixMode,
+) -> Result<Diagnostics> {
+    // Validate the `Settings` and return any errors.
+    settings.validate()?;
+
+    // Check the cache.
+    // TODO(charlie): `fixer::Mode::Apply` and `fixer::Mode::Diff` both have
+    // side-effects that aren't captured in the cache. (In practice, it's fine
+    // to cache `fixer::Mode::Apply`, since a file either has no fixes, or we'll
+    // write the fixes to disk, thus invalidating the cache. But it's a bit hard
+    // to reason about. We need to come up with a better solution here.)
+    let metadata = if matches!(cache, flags::Cache::Enabled)
+        && matches!(autofix, fix::FixMode::None | fix::FixMode::Generate)
+    {
+        let metadata = path.metadata()?;
+        if let Some(messages) = cache::get(path, &metadata, settings, autofix.into()) {
+            debug!("Cache hit for: {}", path.to_string_lossy());
+            return Ok(Diagnostics::new(messages));
+        }
+        Some(metadata)
+    } else {
+        None
+    };
+
+    // Read the file from disk.
+    let contents = fs::read_file(path)?;
+
+    // Lint the file.
+    let (messages, fixed) = if matches!(autofix, fix::FixMode::Apply | fix::FixMode::Diff) {
+        let (transformed, fixed, messages) = lint_fix(&contents, path, package, settings)?;
+        if fixed > 0 {
+            if matches!(autofix, fix::FixMode::Apply) {
+                write(path, transformed)?;
+            } else if matches!(autofix, fix::FixMode::Diff) {
+                let mut stdout = io::stdout().lock();
+                TextDiff::from_lines(&contents, &transformed)
+                    .unified_diff()
+                    .header(&fs::relativize_path(path), &fs::relativize_path(path))
+                    .to_writer(&mut stdout)?;
+                stdout.write_all(b"\n")?;
+                stdout.flush()?;
+            }
+        }
+        (messages, fixed)
+    } else {
+        let messages = lint_only(&contents, path, package, settings, autofix.into())?;
+        let fixed = 0;
+        (messages, fixed)
+    };
+
+    // Re-populate the cache.
+    if let Some(metadata) = metadata {
+        cache::set(path, &metadata, settings, autofix.into(), &messages);
+    }
+
+    Ok(Diagnostics { messages, fixed })
+}
+
+/// Generate `Diagnostic`s from source code content derived from
+/// stdin.
+pub fn lint_stdin(
+    path: Option<&Path>,
+    package: Option<&Path>,
+    contents: &str,
+    settings: &Settings,
+    autofix: fix::FixMode,
+) -> Result<Diagnostics> {
+    // Validate the `Settings` and return any errors.
+    settings.validate()?;
+
+    // Lint the inputs.
+    let (messages, fixed) = if matches!(autofix, fix::FixMode::Apply | fix::FixMode::Diff) {
+        let (transformed, fixed, messages) = lint_fix(
+            contents,
+            path.unwrap_or_else(|| Path::new("-")),
+            package,
+            settings,
+        )?;
+
+        if matches!(autofix, fix::FixMode::Apply) {
+            // Write the contents to stdout, regardless of whether any errors were fixed.
+            io::stdout().write_all(transformed.as_bytes())?;
+        } else if matches!(autofix, fix::FixMode::Diff) {
+            // But only write a diff if it's non-empty.
+            if fixed > 0 {
+                let text_diff = TextDiff::from_lines(contents, &transformed);
+                let mut unified_diff = text_diff.unified_diff();
+                if let Some(path) = path {
+                    unified_diff.header(&fs::relativize_path(path), &fs::relativize_path(path));
+                }
+
+                let mut stdout = io::stdout().lock();
+                unified_diff.to_writer(&mut stdout)?;
+                stdout.write_all(b"\n")?;
+                stdout.flush()?;
+            }
+        }
+
+        (messages, fixed)
+    } else {
+        let messages = lint_only(
+            contents,
+            path.unwrap_or_else(|| Path::new("-")),
+            package,
+            settings,
+            autofix.into(),
+        )?;
+        let fixed = 0;
+        (messages, fixed)
+    };
+
+    Ok(Diagnostics { messages, fixed })
+}
--- a/ruff_cli/src/iterators.rs
+++ b/ruff_cli/src/iterators.rs
--- a/ruff_cli/src/lib.rs
+++ b/ruff_cli/src/lib.rs
@@ -0,0 +1,6 @@
+#![allow(clippy::must_use_candidate, dead_code)]
+
+mod cli;
+
+// used by ruff_dev::generate_cli_help
+pub use cli::Cli;
--- a/ruff_cli/src/main.rs
+++ b/ruff_cli/src/main.rs
@@ -1,24 +1,40 @@
+#![allow(
+    clippy::match_same_arms,
+    clippy::missing_errors_doc,
+    clippy::module_name_repetitions,
+    clippy::too_many_lines
+)]
+#![forbid(unsafe_code)]
+
 use std::io::{self};
 use std::path::{Path, PathBuf};
 use std::process::ExitCode;
 use std::sync::mpsc::channel;

-use ::ruff::autofix::fixer;
-use ::ruff::cli::{extract_log_level, Cli, Overrides};
 use ::ruff::logging::{set_up_logging, LogLevel};
-use ::ruff::printer::{Printer, Violations};
-use ::ruff::resolver::{resolve_settings, FileDiscovery, PyprojectDiscovery, Relativity};
+use ::ruff::resolver::{
+    resolve_settings_with_processor, ConfigProcessor, FileDiscovery, PyprojectDiscovery, Relativity,
+};
 use ::ruff::settings::configuration::Configuration;
 use ::ruff::settings::types::SerializationFormat;
 use ::ruff::settings::{pyproject, Settings};
-#[cfg(feature = "update-informer")]
-use ::ruff::updates;
-use ::ruff::{commands, one_time_warning};
+use ::ruff::{fix, fs, warn_user_once};
 use anyhow::Result;
 use clap::{CommandFactory, Parser};
+use cli::{extract_log_level, Cli, Overrides};
 use colored::Colorize;
 use notify::{recommended_watcher, RecursiveMode, Watcher};
 use path_absolutize::path_dedot;
+use printer::{Printer, Violations};
+
+mod cache;
+mod cli;
+mod commands;
+mod diagnostics;
+mod iterators;
+mod printer;
+#[cfg(all(feature = "update-informer"))]
+pub mod updates;

 /// Resolve the relevant settings strategy and defaults for the current
 /// invocation.
@@ -31,14 +47,14 @@ fn resolve(
    if isolated {
        // First priority: if we're running in isolated mode, use the default settings.
        let mut config = Configuration::default();
-        config.apply(overrides.clone());
+        overrides.process_config(&mut config);
        let settings = Settings::from_configuration(config, &path_dedot::CWD)?;
        Ok(PyprojectDiscovery::Fixed(settings))
    } else if let Some(pyproject) = config {
        // Second priority: the user specified a `pyproject.toml` file. Use that
        // `pyproject.toml` for _all_ configuration, and resolve paths relative to the
        // current working directory. (This matches ESLint's behavior.)
-        let settings = resolve_settings(pyproject, &Relativity::Cwd, Some(overrides))?;
+        let settings = resolve_settings_with_processor(pyproject, &Relativity::Cwd, overrides)?;
        Ok(PyprojectDiscovery::Fixed(settings))
    } else if let Some(pyproject) = pyproject::find_settings_toml(
        stdin_filename
@@ -50,14 +66,14 @@ fn resolve(
        // that directory. (With `Strategy::Hierarchical`, we'll end up finding
        // the "closest" `pyproject.toml` file for every Python file later on,
        // so these act as the "default" settings.)
-        let settings = resolve_settings(&pyproject, &Relativity::Parent, Some(overrides))?;
+        let settings = resolve_settings_with_processor(&pyproject, &Relativity::Parent, overrides)?;
        Ok(PyprojectDiscovery::Hierarchical(settings))
    } else if let Some(pyproject) = pyproject::find_user_settings_toml() {
        // Fourth priority: find a user-specific `pyproject.toml`, but resolve all paths
        // relative the current working directory. (With `Strategy::Hierarchical`, we'll
        // end up the "closest" `pyproject.toml` file for every Python file later on, so
        // these act as the "default" settings.)
-        let settings = resolve_settings(&pyproject, &Relativity::Cwd, Some(overrides))?;
+        let settings = resolve_settings_with_processor(&pyproject, &Relativity::Cwd, overrides)?;
        Ok(PyprojectDiscovery::Hierarchical(settings))
    } else {
        // Fallback: load Ruff's default settings, and resolve all paths relative to the
@@ -65,13 +81,13 @@ fn resolve(
        // "closest" `pyproject.toml` file for every Python file later on, so these act
        // as the "default" settings.)
        let mut config = Configuration::default();
-        config.apply(overrides.clone());
+        overrides.process_config(&mut config);
        let settings = Settings::from_configuration(config, &path_dedot::CWD)?;
        Ok(PyprojectDiscovery::Hierarchical(settings))
    }
 }

-pub(crate) fn inner_main() -> Result<ExitCode> {
+pub fn main() -> Result<ExitCode> {
    // Extract command-line arguments.
    let (cli, overrides) = Cli::parse().partition();
    let log_level = extract_log_level(&cli);
@@ -129,7 +145,7 @@ pub(crate) fn inner_main() -> Result<ExitCode> {
    };

    if let Some(code) = cli.explain {
-        commands::explain(&code, &format)?;
+        commands::explain(&code, format)?;
        return Ok(ExitCode::SUCCESS);
    }
    if cli.show_settings {
@@ -152,13 +168,13 @@ pub(crate) fn inner_main() -> Result<ExitCode> {
    // but not apply fixes. That would allow us to avoid special-casing JSON
    // here.
    let autofix = if cli.diff {
-        fixer::Mode::Diff
+        fix::FixMode::Diff
    } else if fix || fix_only {
-        fixer::Mode::Apply
+        fix::FixMode::Apply
    } else if matches!(format, SerializationFormat::Json) {
-        fixer::Mode::Generate
+        fix::FixMode::Generate
    } else {
-        fixer::Mode::None
+        fix::FixMode::None
    };
    let violations = if cli.diff || fix_only {
        Violations::Hide
@@ -171,31 +187,16 @@ pub(crate) fn inner_main() -> Result<ExitCode> {
    if cache {
        // `--no-cache` doesn't respect code changes, and so is often confusing during
        // development.
-        one_time_warning!(
-            "{}{} {}",
-            "warning".yellow().bold(),
-            ":".bold(),
-            "debug build without --no-cache.".bold()
-        );
+        warn_user_once!("debug build without --no-cache.");
    }

    let printer = Printer::new(&format, &log_level, &autofix, &violations);
    if cli.watch {
-        if !matches!(autofix, fixer::Mode::None) {
-            one_time_warning!(
-                "{}{} {}",
-                "warning".yellow().bold(),
-                ":".bold(),
-                "--fix is not enabled in watch mode.".bold()
-            );
+        if !matches!(autofix, fix::FixMode::None) {
+            warn_user_once!("--fix is not enabled in watch mode.");
        }
        if format != SerializationFormat::Text {
-            one_time_warning!(
-                "{}{} {}",
-                "warning".yellow().bold(),
-                ":".bold(),
-                "--format 'text' is used in watch mode.".bold()
-            );
+            warn_user_once!("--format 'text' is used in watch mode.");
        }

        // Perform an initial run instantly.
@@ -208,9 +209,9 @@ pub(crate) fn inner_main() -> Result<ExitCode> {
            &file_strategy,
            &overrides,
            cache.into(),
-            fixer::Mode::None,
+            fix::FixMode::None,
        )?;
-        printer.write_continuously(&messages)?;
+        printer.write_continuously(&messages);

        // Configure the file watcher.
        let (tx, rx) = channel();
@@ -238,9 +239,9 @@ pub(crate) fn inner_main() -> Result<ExitCode> {
                            &file_strategy,
                            &overrides,
                            cache.into(),
-                            fixer::Mode::None,
+                            fix::FixMode::None,
                        )?;
-                        printer.write_continuously(&messages)?;
+                        printer.write_continuously(&messages);
                    }
                }
                Err(err) => return Err(err.into()),
@@ -258,7 +259,7 @@ pub(crate) fn inner_main() -> Result<ExitCode> {
        // Generate lint violations.
        let diagnostics = if is_stdin {
            commands::run_stdin(
-                cli.stdin_filename.as_deref(),
+                cli.stdin_filename.map(fs::normalize_path).as_deref(),
                &pyproject_strategy,
                &file_strategy,
                &overrides,
@@ -278,7 +279,7 @@ pub(crate) fn inner_main() -> Result<ExitCode> {
        // Always try to print violations (the printer itself may suppress output),
        // unless we're writing fixes via stdin (in which case, the transformed
        // source code goes to stdout).
-        if !(is_stdin && matches!(autofix, fixer::Mode::Apply | fixer::Mode::Diff)) {
+        if !(is_stdin && matches!(autofix, fix::FixMode::Apply | fix::FixMode::Diff)) {
            printer.write_once(&diagnostics)?;
        }

--- a/ruff_cli/src/printer.rs
+++ b/ruff_cli/src/printer.rs
@@ -6,18 +6,16 @@ use annotate_snippets::snippet::{Annotation, AnnotationType, Slice, Snippet, Sou
 use anyhow::Result;
 use colored::Colorize;
 use itertools::iterate;
-use rustpython_parser::ast::Location;
+use ruff::fs::relativize_path;
+use ruff::logging::LogLevel;
+use ruff::message::{Location, Message};
+use ruff::registry::RuleCode;
+use ruff::settings::types::SerializationFormat;
+use ruff::{fix, notify_user};
 use serde::Serialize;
 use serde_json::json;

-use crate::autofix::fixer;
-use crate::fs::relativize_path;
-use crate::linter::Diagnostics;
-use crate::logging::LogLevel;
-use crate::message::Message;
-use crate::registry::CheckCode;
-use crate::settings::types::SerializationFormat;
-use crate::tell_user;
+use crate::diagnostics::Diagnostics;

 /// Enum to control whether lint violations are shown to the user.
 pub enum Violations {
@@ -35,7 +33,7 @@ struct ExpandedFix<'a> {

 #[derive(Serialize)]
 struct ExpandedMessage<'a> {
-    code: &'a CheckCode,
+    code: &'a RuleCode,
    message: String,
    fix: Option<ExpandedFix<'a>>,
    location: Location,
@@ -46,7 +44,7 @@ struct ExpandedMessage<'a> {
 pub struct Printer<'a> {
    format: &'a SerializationFormat,
    log_level: &'a LogLevel,
-    autofix: &'a fixer::Mode,
+    autofix: &'a fix::FixMode,
    violations: &'a Violations,
 }

@@ -54,7 +52,7 @@ impl<'a> Printer<'a> {
    pub fn new(
        format: &'a SerializationFormat,
        log_level: &'a LogLevel,
-        autofix: &'a fixer::Mode,
+        autofix: &'a fix::FixMode,
        violations: &'a Violations,
    ) -> Self {
        Self {
@@ -67,7 +65,7 @@ impl<'a> Printer<'a> {

    pub fn write_to_user(&self, message: &str) {
        if self.log_level >= &LogLevel::Default {
-            tell_user!("{}", message);
+            notify_user!("{}", message);
        }
    }

@@ -84,7 +82,7 @@ impl<'a> Printer<'a> {
                        println!("Found {remaining} error(s).");
                    }

-                    if !matches!(self.autofix, fixer::Mode::Apply) {
+                    if !matches!(self.autofix, fix::FixMode::Apply) {
                        let num_fixable = diagnostics
                            .messages
                            .iter()
@@ -98,9 +96,9 @@ impl<'a> Printer<'a> {
                Violations::Hide => {
                    let fixed = diagnostics.fixed;
                    if fixed > 0 {
-                        if matches!(self.autofix, fixer::Mode::Apply) {
+                        if matches!(self.autofix, fix::FixMode::Apply) {
                            println!("Fixed {fixed} error(s).");
-                        } else if matches!(self.autofix, fixer::Mode::Diff) {
+                        } else if matches!(self.autofix, fix::FixMode::Diff) {
                            println!("Would fix {fixed} error(s).");
                        }
                    }
@@ -241,7 +239,7 @@ impl<'a> Printer<'a> {
                        "::error title=Ruff \
                         ({}),file={},line={},col={},endLine={},endColumn={}::{}",
                        message.kind.code(),
-                        relativize_path(Path::new(&message.filename)),
+                        message.filename,
                        message.location.row(),
                        message.location.column(),
                        message.end_location.row(),
@@ -265,7 +263,7 @@ impl<'a> Printer<'a> {
                                    "severity": "major",
                                    "fingerprint": message.kind.code(),
                                    "location": {
-                                        "path": relativize_path(Path::new(&message.filename)),
+                                        "path": message.filename,
                                        "lines": {
                                            "begin": message.location.row(),
                                            "end": message.end_location.row()
@@ -283,13 +281,13 @@ impl<'a> Printer<'a> {
        Ok(())
    }

-    pub fn write_continuously(&self, diagnostics: &Diagnostics) -> Result<()> {
+    pub fn write_continuously(&self, diagnostics: &Diagnostics) {
        if matches!(self.log_level, LogLevel::Silent) {
-            return Ok(());
+            return;
        }

        if self.log_level >= &LogLevel::Default {
-            tell_user!(
+            notify_user!(
                "Found {} error(s). Watching for file changes.",
                diagnostics.messages.len()
            );
@@ -303,10 +301,9 @@ impl<'a> Printer<'a> {
                print_message(message);
            }
        }
-
-        Ok(())
    }

+    #[allow(clippy::unused_self)]
    pub fn clear_screen(&self) -> Result<()> {
        #[cfg(not(target_family = "wasm"))]
        clearscreen::clear()?;
--- a/ruff_cli/src/updates.rs
+++ b/ruff_cli/src/updates.rs
--- a/ruff_cli/tests/black_compatibility_test.rs
+++ b/ruff_cli/tests/black_compatibility_test.rs
@@ -9,11 +9,11 @@ use std::time::Duration;
 use std::{fs, process, str};

 use anyhow::{anyhow, Context, Result};
-use assert_cmd::{crate_name, Command};
+use assert_cmd::Command;
 use itertools::Itertools;
 use log::info;
 use ruff::logging::{set_up_logging, LogLevel};
-use ruff::registry::CheckCategory;
+use ruff::registry::RuleOrigin;
 use strum::IntoEnumIterator;
 use walkdir::WalkDir;

@@ -24,6 +24,8 @@ struct Blackd {
    client: ureq::Agent,
 }

+const BIN_NAME: &str = "ruff";
+
 impl Blackd {
    pub fn new() -> Result<Self> {
        // Get free TCP port to run on
@@ -104,7 +106,7 @@ fn run_test(path: &Path, blackd: &Blackd, ruff_args: &[&str]) -> Result<()> {
    let input = fs::read(path)?;

    // Step 1: Run `ruff` on the input.
-    let step_1 = &Command::cargo_bin(crate_name!())?
+    let step_1 = &Command::cargo_bin(BIN_NAME)?
        .args(ruff_args)
        .write_stdin(input)
        .assert()
@@ -121,7 +123,7 @@ fn run_test(path: &Path, blackd: &Blackd, ruff_args: &[&str]) -> Result<()> {
    let step_2_output = blackd.check(&step_1_output)?;

    // Step 3: Re-run `ruff` on the input.
-    let step_3 = &Command::cargo_bin(crate_name!())?
+    let step_3 = &Command::cargo_bin(BIN_NAME)?
        .args(ruff_args)
        .write_stdin(step_2_output.clone())
        .assert();
@@ -173,12 +175,12 @@ fn test_ruff_black_compatibility() -> Result<()> {
        .filter_map(Result::ok)
        .collect();

-    let codes = CheckCategory::iter()
+    let codes = RuleOrigin::iter()
        // Exclude ruff codes, specifically RUF100, because it causes differences that are not a
        // problem. Ruff would add a `# noqa: W292`  after the first run, black introduces a
        // newline, and ruff removes the `# noqa: W292` again.
-        .filter(|category| *category != CheckCategory::Ruff)
-        .map(|category| category.codes().iter().map(AsRef::as_ref).join(","))
+        .filter(|origin| *origin != RuleOrigin::Ruff)
+        .map(|origin| origin.codes().iter().map(AsRef::as_ref).join(","))
        .join(",");
    let ruff_args = [
        "-",
--- a/ruff_cli/tests/integration_test.rs
+++ b/ruff_cli/tests/integration_test.rs
@@ -3,11 +3,14 @@
 use std::str;

 use anyhow::Result;
-use assert_cmd::{crate_name, Command};
+use assert_cmd::Command;
+use path_absolutize::path_dedot;
+
+const BIN_NAME: &str = "ruff";

 #[test]
 fn test_stdin_success() -> Result<()> {
-    let mut cmd = Command::cargo_bin(crate_name!())?;
+    let mut cmd = Command::cargo_bin(BIN_NAME)?;
    cmd.args(["-", "--format", "text"])
        .write_stdin("")
        .assert()
@@ -17,7 +20,7 @@ fn test_stdin_success() -> Result<()> {

 #[test]
 fn test_stdin_error() -> Result<()> {
-    let mut cmd = Command::cargo_bin(crate_name!())?;
+    let mut cmd = Command::cargo_bin(BIN_NAME)?;
    let output = cmd
        .args(["-", "--format", "text"])
        .write_stdin("import os\n")
@@ -33,7 +36,7 @@ fn test_stdin_error() -> Result<()> {

 #[test]
 fn test_stdin_filename() -> Result<()> {
-    let mut cmd = Command::cargo_bin(crate_name!())?;
+    let mut cmd = Command::cargo_bin(BIN_NAME)?;
    let output = cmd
        .args(["-", "--format", "text", "--stdin-filename", "F401.py"])
        .write_stdin("import os\n")
@@ -49,7 +52,7 @@ fn test_stdin_filename() -> Result<()> {

 #[test]
 fn test_stdin_json() -> Result<()> {
-    let mut cmd = Command::cargo_bin(crate_name!())?;
+    let mut cmd = Command::cargo_bin(BIN_NAME)?;
    let output = cmd
        .args(["-", "--format", "json", "--stdin-filename", "F401.py"])
        .write_stdin("import os\n")
@@ -57,41 +60,44 @@ fn test_stdin_json() -> Result<()> {
        .failure();
    assert_eq!(
        str::from_utf8(&output.get_output().stdout)?,
-        r#"[
-  {
+        format!(
+            r#"[
+  {{
    "code": "F401",
    "message": "`os` imported but unused",
-    "fix": {
+    "fix": {{
      "content": "",
      "message": "Remove unused import: `os`",
-      "location": {
+      "location": {{
        "row": 1,
        "column": 0
-      },
-      "end_location": {
+      }},
+      "end_location": {{
        "row": 2,
        "column": 0
-      }
-    },
-    "location": {
+      }}
+    }},
+    "location": {{
      "row": 1,
      "column": 8
-    },
-    "end_location": {
+    }},
+    "end_location": {{
      "row": 1,
      "column": 10
-    },
-    "filename": "F401.py"
-  }
+    }},
+    "filename": "{}/F401.py"
+  }}
 ]
-"#
+"#,
+            path_dedot::CWD.to_str().unwrap()
+        )
    );
    Ok(())
 }

 #[test]
 fn test_stdin_autofix() -> Result<()> {
-    let mut cmd = Command::cargo_bin(crate_name!())?;
+    let mut cmd = Command::cargo_bin(BIN_NAME)?;
    let output = cmd
        .args(["-", "--format", "text", "--fix"])
        .write_stdin("import os\nimport sys\n\nprint(sys.version)\n")
@@ -106,7 +112,7 @@ fn test_stdin_autofix() -> Result<()> {

 #[test]
 fn test_stdin_autofix_when_not_fixable_should_still_print_contents() -> Result<()> {
-    let mut cmd = Command::cargo_bin(crate_name!())?;
+    let mut cmd = Command::cargo_bin(BIN_NAME)?;
    let output = cmd
        .args(["-", "--format", "text", "--fix"])
        .write_stdin("import os\nimport sys\n\nif (1, 2):\n     print(sys.version)\n")
@@ -121,7 +127,7 @@ fn test_stdin_autofix_when_not_fixable_should_still_print_contents() -> Result<(

 #[test]
 fn test_stdin_autofix_when_no_issues_should_still_print_contents() -> Result<()> {
-    let mut cmd = Command::cargo_bin(crate_name!())?;
+    let mut cmd = Command::cargo_bin(BIN_NAME)?;
    let output = cmd
        .args(["-", "--format", "text", "--fix"])
        .write_stdin("import sys\n\nprint(sys.version)\n")
@@ -136,7 +142,7 @@ fn test_stdin_autofix_when_no_issues_should_still_print_contents() -> Result<()>

 #[test]
 fn test_show_source() -> Result<()> {
-    let mut cmd = Command::cargo_bin(crate_name!())?;
+    let mut cmd = Command::cargo_bin(BIN_NAME)?;
    let output = cmd
        .args(["-", "--format", "text", "--show-source"])
        .write_stdin("l = 1")
--- a/ruff_dev/Cargo.toml
+++ b/ruff_dev/Cargo.toml
@@ -1,8 +1,12 @@
 [package]
 name = "ruff_dev"
-version = "0.0.215"
+version = "0.0.221"
 edition = "2021"

+[lib]
+name = "ruff_dev"
+doctest = false
+
 [dependencies]
 anyhow = { version = "1.0.66" }
 clap = { version = "4.0.1", features = ["derive"] }
@@ -10,6 +14,7 @@ itertools = { version = "0.10.5" }
 libcst = { git = "https://github.com/charliermarsh/LibCST", rev = "f2f0b7a487a8725d161fe8b3ed73a6758b21e177" }
 once_cell = { version = "1.16.0" }
 ruff = { path = ".." }
+ruff_cli = { path = "../ruff_cli" }
 rustpython-ast = { features = ["unparse"], git = "https://github.com/RustPython/RustPython.git", rev = "d532160333ffeb6dbeca2c2728c2391cd1e53b7f" }
 rustpython-common = { git = "https://github.com/RustPython/RustPython.git", rev = "d532160333ffeb6dbeca2c2728c2391cd1e53b7f" }
 rustpython-parser = { features = ["lalrpop"], git = "https://github.com/RustPython/RustPython.git", rev = "d532160333ffeb6dbeca2c2728c2391cd1e53b7f" }
--- a/ruff_dev/src/generate_cli_help.rs
+++ b/ruff_dev/src/generate_cli_help.rs
@@ -2,7 +2,7 @@

 use anyhow::Result;
 use clap::{Args, CommandFactory};
-use ruff::cli::Cli as MainCli;
+use ruff_cli::Cli as MainCli;

 use crate::utils::replace_readme_section;

--- a/ruff_dev/src/generate_rules_table.rs
+++ b/ruff_dev/src/generate_rules_table.rs
@@ -3,7 +3,7 @@
 use anyhow::Result;
 use clap::Args;
 use itertools::Itertools;
-use ruff::registry::{CheckCategory, CheckCode};
+use ruff::registry::{RuleCode, RuleOrigin};
 use strum::IntoEnumIterator;

 use crate::utils::replace_readme_section;
@@ -25,24 +25,24 @@ pub fn main(cli: &Cli) -> Result<()> {
    // Generate the table string.
    let mut table_out = String::new();
    let mut toc_out = String::new();
-    for check_category in CheckCategory::iter() {
-        let codes_csv: String = check_category.codes().iter().map(AsRef::as_ref).join(", ");
-        table_out.push_str(&format!("### {} ({codes_csv})", check_category.title()));
+    for origin in RuleOrigin::iter() {
+        let codes_csv: String = origin.codes().iter().map(AsRef::as_ref).join(", ");
+        table_out.push_str(&format!("### {} ({codes_csv})", origin.title()));
        table_out.push('\n');
        table_out.push('\n');

        toc_out.push_str(&format!(
            "   1. [{} ({})](#{}-{})\n",
-            check_category.title(),
+            origin.title(),
            codes_csv,
-            check_category.title().to_lowercase().replace(' ', "-"),
+            origin.title().to_lowercase().replace(' ', "-"),
            codes_csv.to_lowercase().replace(',', "-").replace(' ', "")
        ));

-        if let Some((url, platform)) = check_category.url() {
+        if let Some((url, platform)) = origin.url() {
            table_out.push_str(&format!(
                "For more, see [{}]({}) on {}.",
-                check_category.title(),
+                origin.title(),
                url,
                platform
            ));
@@ -55,15 +55,15 @@ pub fn main(cli: &Cli) -> Result<()> {
        table_out.push_str("| ---- | ---- | ------- | --- |");
        table_out.push('\n');

-        for check_code in CheckCode::iter() {
-            if check_code.category() == check_category {
-                let check_kind = check_code.kind();
-                let fix_token = if check_kind.fixable() { "🛠" } else { "" };
+        for rule_code in RuleCode::iter() {
+            if rule_code.origin() == origin {
+                let kind = rule_code.kind();
+                let fix_token = if kind.fixable() { "🛠" } else { "" };
                table_out.push_str(&format!(
                    "| {} | {} | {} | {} |",
-                    check_kind.code().as_ref(),
-                    check_kind.as_ref(),
-                    check_kind.summary().replace('|', r"\|"),
+                    kind.code().as_ref(),
+                    kind.as_ref(),
+                    kind.summary().replace('|', r"\|"),
                    fix_token
                ));
                table_out.push('\n');
--- a/ruff_dev/src/round_trip.rs
+++ b/ruff_dev/src/round_trip.rs
@@ -5,9 +5,7 @@ use std::path::PathBuf;

 use anyhow::Result;
 use clap::Args;
-use ruff::source_code_generator::SourceCodeGenerator;
-use ruff::source_code_locator::SourceCodeLocator;
-use ruff::source_code_style::SourceCodeStyleDetector;
+use ruff::source_code::{Generator, Locator, Stylist};
 use rustpython_parser::parser;

 #[derive(Args)]
@@ -20,9 +18,9 @@ pub struct Cli {
 pub fn main(cli: &Cli) -> Result<()> {
    let contents = fs::read_to_string(&cli.file)?;
    let python_ast = parser::parse_program(&contents, &cli.file.to_string_lossy())?;
-    let locator = SourceCodeLocator::new(&contents);
-    let stylist = SourceCodeStyleDetector::from_contents(&contents, &locator);
-    let mut generator: SourceCodeGenerator = (&stylist).into();
+    let locator = Locator::new(&contents);
+    let stylist = Stylist::from_contents(&contents, &locator);
+    let mut generator: Generator = (&stylist).into();
    generator.unparse_suite(&python_ast);
    println!("{}", generator.generate());
    Ok(())
--- a/ruff_macros/Cargo.toml
+++ b/ruff_macros/Cargo.toml
@@ -1,10 +1,11 @@
 [package]
 name = "ruff_macros"
-version = "0.0.215"
+version = "0.0.221"
 edition = "2021"

 [lib]
 proc-macro = true
+doctest = false

 [dependencies]
 once_cell = { version = "1.17.0" }
--- a/ruff_macros/src/lib.rs
+++ b/ruff_macros/src/lib.rs
@@ -12,10 +12,13 @@
 )]
 #![forbid(unsafe_code)]

-use syn::{parse_macro_input, DeriveInput};
+use proc_macro2::Span;
+use quote::quote;
+use syn::{parse_macro_input, DeriveInput, Ident};

-mod check_code_prefix;
 mod config;
+mod prefixes;
+mod rule_code_prefix;

 #[proc_macro_derive(ConfigurationOptions, attributes(option, doc, option_group))]
 pub fn derive_config(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
@@ -26,11 +29,31 @@ pub fn derive_config(input: proc_macro::TokenStream) -> proc_macro::TokenStream
        .into()
 }

-#[proc_macro_derive(CheckCodePrefix)]
-pub fn derive_check_code_prefix(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
+#[proc_macro_derive(RuleCodePrefix)]
+pub fn derive_rule_code_prefix(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
    let input = parse_macro_input!(input as DeriveInput);

-    check_code_prefix::derive_impl(input)
+    rule_code_prefix::derive_impl(input)
        .unwrap_or_else(syn::Error::into_compile_error)
        .into()
 }
+
+#[proc_macro]
+pub fn origin_by_code(item: proc_macro::TokenStream) -> proc_macro::TokenStream {
+    let ident = parse_macro_input!(item as Ident).to_string();
+    let mut iter = prefixes::PREFIX_TO_ORIGIN.iter();
+    let origin = loop {
+        let (prefix, origin) = iter
+            .next()
+            .unwrap_or_else(|| panic!("code doesn't start with any recognized prefix: {ident}"));
+        if ident.starts_with(prefix) {
+            break origin;
+        }
+    };
+    let prefix = Ident::new(origin, Span::call_site());
+
+    quote! {
+        RuleOrigin::#prefix
+    }
+    .into()
+}
--- a/ruff_macros/src/prefixes.rs
+++ b/ruff_macros/src/prefixes.rs
@@ -0,0 +1,53 @@
+// Longer prefixes should come first so that you can find an origin for a code
+// by simply picking the first entry that starts with the given prefix.
+
+pub const PREFIX_TO_ORIGIN: &[(&str, &str)] = &[
+    ("ANN", "Flake8Annotations"),
+    ("ARG", "Flake8UnusedArguments"),
+    ("A", "Flake8Builtins"),
+    ("BLE", "Flake8BlindExcept"),
+    ("B", "Flake8Bugbear"),
+    ("C4", "Flake8Comprehensions"),
+    ("C9", "McCabe"),
+    ("DTZ", "Flake8Datetimez"),
+    ("D", "Pydocstyle"),
+    ("ERA", "Eradicate"),
+    ("EM", "Flake8ErrMsg"),
+    ("E", "Pycodestyle"),
+    ("FBT", "Flake8BooleanTrap"),
+    ("F", "Pyflakes"),
+    ("ICN", "Flake8ImportConventions"),
+    ("ISC", "Flake8ImplicitStrConcat"),
+    ("I", "Isort"),
+    ("N", "PEP8Naming"),
+    ("PD", "PandasVet"),
+    ("PGH", "PygrepHooks"),
+    ("PL", "Pylint"),
+    ("PT", "Flake8PytestStyle"),
+    ("Q", "Flake8Quotes"),
+    ("RET", "Flake8Return"),
+    ("SIM", "Flake8Simplify"),
+    ("S", "Flake8Bandit"),
+    ("T10", "Flake8Debugger"),
+    ("T20", "Flake8Print"),
+    ("TID", "Flake8TidyImports"),
+    ("UP", "Pyupgrade"),
+    ("W", "Pycodestyle"),
+    ("YTT", "Flake82020"),
+    ("PIE", "Flake8Pie"),
+    ("RUF", "Ruff"),
+];
+
+#[cfg(test)]
+mod tests {
+    use super::PREFIX_TO_ORIGIN;
+
+    #[test]
+    fn order() {
+        for (idx, (prefix, _)) in PREFIX_TO_ORIGIN.iter().enumerate() {
+            for (prior_prefix, _) in PREFIX_TO_ORIGIN[..idx].iter() {
+                assert!(!prefix.starts_with(prior_prefix));
+            }
+        }
+    }
+}
--- a/ruff_macros/src/check_code_prefix.rs
+++ b/ruff_macros/src/check_code_prefix.rs
@@ -9,7 +9,8 @@ use syn::{DataEnum, DeriveInput, Ident, Variant};

 const ALL: &str = "ALL";

-/// A hash map from deprecated `CheckCodePrefix` to latest `CheckCodePrefix`.
+/// A hash map from deprecated `RuleCodePrefix` to latest
+/// `RuleCodePrefix`.
 pub static PREFIX_REDIRECTS: Lazy<HashMap<&'static str, &'static str>> = Lazy::new(|| {
    HashMap::from_iter([
        // TODO(charlie): Remove by 2023-01-01.
@@ -90,7 +91,7 @@ pub fn derive_impl(input: DeriveInput) -> syn::Result<proc_macro2::TokenStream>
    let syn::Data::Enum(DataEnum { variants, .. }) = data else {
        return Err(syn::Error::new(
            ident.span(),
-            "Can only derive `CheckCodePrefix` from enums.",
+            "Can only derive `RuleCodePrefix` from enums.",
        ));
    };

@@ -117,7 +118,7 @@ fn expand(
    prefix_ident: &Ident,
    variants: &Punctuated<Variant, Comma>,
 ) -> proc_macro2::TokenStream {
-    // Build up a map from prefix to matching CheckCodes.
+    // Build up a map from prefix to matching RuleCodes.
    let mut prefix_to_codes: BTreeMap<Ident, BTreeSet<String>> = BTreeMap::default();
    for variant in variants {
        let span = variant.ident.span();
@@ -141,12 +142,12 @@ fn expand(
    }

    // Add any prefix aliases (e.g., "U" to "UP").
-    for (alias, check_code) in PREFIX_REDIRECTS.iter() {
+    for (alias, rule_code) in PREFIX_REDIRECTS.iter() {
        prefix_to_codes.insert(
            Ident::new(alias, Span::call_site()),
            prefix_to_codes
-                .get(&Ident::new(check_code, Span::call_site()))
-                .unwrap_or_else(|| panic!("Unknown CheckCode: {alias:?}"))
+                .get(&Ident::new(rule_code, Span::call_site()))
+                .unwrap_or_else(|| panic!("Unknown RuleCode: {alias:?}"))
                .clone(),
        );
    }
@@ -159,8 +160,8 @@ fn expand(

    let prefix_impl = generate_impls(ident, prefix_ident, &prefix_to_codes);

-    let prefix_redirects = PREFIX_REDIRECTS.iter().map(|(alias, check_code)| {
-        let code = Ident::new(check_code, Span::call_site());
+    let prefix_redirects = PREFIX_REDIRECTS.iter().map(|(alias, rule_code)| {
+        let code = Ident::new(rule_code, Span::call_site());
        quote! {
            (#alias, #prefix_ident::#code)
        }
@@ -186,7 +187,7 @@ fn expand(

        #prefix_impl

-        /// A hash map from deprecated `CheckCodePrefix` to latest `CheckCodePrefix`.
+        /// A hash map from deprecated `RuleCodePrefix` to latest `RuleCodePrefix`.
        pub static PREFIX_REDIRECTS: ::once_cell::sync::Lazy<::rustc_hash::FxHashMap<&'static str, #prefix_ident>> = ::once_cell::sync::Lazy::new(|| {
            ::rustc_hash::FxHashMap::from_iter([
                #(#prefix_redirects),*
@@ -211,11 +212,8 @@ fn generate_impls(
        if let Some(target) = PREFIX_REDIRECTS.get(prefix_str.as_str()) {
            quote! {
                #prefix_ident::#prefix => {
-                    crate::one_time_warning!(
-                        "{}{} {}",
-                        "warning".yellow().bold(),
-                        ":".bold(),
-                        format!("`{}` has been remapped to `{}`", #prefix_str, #target).bold()
+                    crate::warn_user_once!(
+                        "`{}` has been remapped to `{}`", #prefix_str, #target
                    );
                    vec![#(#codes),*]
                }
--- a/scripts/add_check.py
+++ b/scripts/add_check.py
@@ -1,139 +0,0 @@
-#!/usr/bin/env python3
-"""Generate boilerplate for a new check.
-
-Example usage:
-
-    python scripts/add_check.py \
-        --name PreferListBuiltin \
-        --code PIE807 \
-        --plugin flake8-pie
-"""
-
-import argparse
-import os
-
-ROOT_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
-
-
-def dir_name(plugin: str) -> str:
-    return plugin.replace("-", "_")
-
-
-def pascal_case(plugin: str) -> str:
-    """Convert from snake-case to PascalCase."""
-    return "".join(word.title() for word in plugin.split("-"))
-
-
-def snake_case(name: str) -> str:
-    """Convert from PascalCase to snake_case."""
-    return "".join(f"_{word.lower()}" if word.isupper() else word for word in name).lstrip("_")
-
-
-def main(*, name: str, code: str, plugin: str) -> None:
-    # Create a test fixture.
-    with open(
-        os.path.join(ROOT_DIR, f"resources/test/fixtures/{dir_name(plugin)}/{code}.py"),
-        "a",
-    ):
-        pass
-
-    # Add the relevant `#testcase` macro.
-    with open(os.path.join(ROOT_DIR, f"src/{dir_name(plugin)}/mod.rs"), "r") as fp:
-        content = fp.read()
-
-    with open(os.path.join(ROOT_DIR, f"src/{dir_name(plugin)}/mod.rs"), "w") as fp:
-        for line in content.splitlines():
-            if line.strip() == "fn checks(check_code: CheckCode, path: &Path) -> Result<()> {":
-                indent = line.split("fn checks(check_code: CheckCode, path: &Path) -> Result<()> {")[0]
-                fp.write(f'{indent}#[test_case(CheckCode::{code}, Path::new("{code}.py"); "{code}")]')
-                fp.write("\n")
-
-            fp.write(line)
-            fp.write("\n")
-
-    # Add the relevant plugin function.
-    with open(os.path.join(ROOT_DIR, f"src/{dir_name(plugin)}/plugins.rs"), "a") as fp:
-        fp.write(
-            f"""
-/// {code}
-pub fn {snake_case(name)}(checker: &mut Checker) {{}}
-"""
-        )
-        fp.write("\n")
-
-    # Add the relevant sections to `src/registry.rs`.
-    with open(os.path.join(ROOT_DIR, "src/registry.rs"), "r") as fp:
-        content = fp.read()
-
-    index = 0
-    with open(os.path.join(ROOT_DIR, "src/registry.rs"), "w") as fp:
-        for line in content.splitlines():
-            fp.write(line)
-            fp.write("\n")
-
-            if line.strip() == f"// {plugin}":
-                if index == 0:
-                    # `CheckCode` definition
-                    indent = line.split(f"// {plugin}")[0]
-                    fp.write(f"{indent}{code},")
-                    fp.write("\n")
-
-                elif index == 1:
-                    # `CheckKind` definition
-                    indent = line.split(f"// {plugin}")[0]
-                    fp.write(f"{indent}{name},")
-                    fp.write("\n")
-
-                elif index == 2:
-                    # `CheckCode#kind()`
-                    indent = line.split(f"// {plugin}")[0]
-                    fp.write(f"{indent}CheckCode::{code} => CheckKind::{name},")
-                    fp.write("\n")
-
-                elif index == 3:
-                    # `CheckCode#category()`
-                    indent = line.split(f"// {plugin}")[0]
-                    fp.write(f"{indent}CheckCode::{code} => CheckCategory::{pascal_case(plugin)},")
-                    fp.write("\n")
-
-                elif index == 4:
-                    # `CheckKind#code()`
-                    indent = line.split(f"// {plugin}")[0]
-                    fp.write(f"{indent}CheckKind::{name} => &CheckCode::{code},")
-                    fp.write("\n")
-
-                elif index == 5:
-                    # `CheckCode#body`
-                    indent = line.split(f"// {plugin}")[0]
-                    fp.write(f'{indent}CheckKind::{name} => todo!("Write message body for {code}"),')
-                    fp.write("\n")
-
-                index += 1
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser(
-        description="Generate boilerplate for a new check.",
-        epilog="python scripts/add_check.py --name PreferListBuiltin --code PIE807 --plugin flake8-pie",
-    )
-    parser.add_argument(
-        "--name",
-        type=str,
-        required=True,
-        help="The name of the check to generate, in PascalCase (e.g., 'LineTooLong').",
-    )
-    parser.add_argument(
-        "--code",
-        type=str,
-        required=True,
-        help="The code of the check to generate (e.g., 'A001').",
-    )
-    parser.add_argument(
-        "--plugin",
-        type=str,
-        required=True,
-        help="The plugin with which the check is associated (e.g., 'flake8-builtins').",
-    )
-    args = parser.parse_args()
-
-    main(name=args.name, code=args.code, plugin=args.plugin)
--- a/scripts/add_plugin.py
+++ b/scripts/add_plugin.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-"""Generate boilerplate for a new plugin.
+"""Generate boilerplate for a new Flake8 plugin.

 Example usage:

@@ -31,10 +31,10 @@ def main(*, plugin: str, url: str) -> None:

    # Create the Rust module.
    os.makedirs(os.path.join(ROOT_DIR, f"src/{dir_name(plugin)}"), exist_ok=True)
-    with open(os.path.join(ROOT_DIR, f"src/{dir_name(plugin)}/plugins.rs"), "a"):
-        pass
+    with open(os.path.join(ROOT_DIR, f"src/{dir_name(plugin)}/rules.rs"), "w+") as fp:
+        fp.write("use crate::checkers::ast::Checker;\n")
    with open(os.path.join(ROOT_DIR, f"src/{dir_name(plugin)}/mod.rs"), "w+") as fp:
-        fp.write("pub mod plugins;\n")
+        fp.write("pub(crate) mod rules;\n")
        fp.write("\n")
        fp.write(
            """#[cfg(test)]
@@ -45,19 +45,19 @@ mod tests {
    use anyhow::Result;
    use test_case::test_case;

-    use crate::registry::CheckCode;
+    use crate::registry::RuleCode;
    use crate::linter::test_path;
    use crate::settings;

-    fn checks(check_code: CheckCode, path: &Path) -> Result<()> {
-        let snapshot = format!("{}_{}", check_code.as_ref(), path.to_string_lossy());
-        let checks = test_path(
+    fn rules(rule_code: RuleCode, path: &Path) -> Result<()> {
+        let snapshot = format!("{}_{}", rule_code.as_ref(), path.to_string_lossy());
+        let diagnostics =test_path(
            Path::new("./resources/test/fixtures/%s")
                .join(path)
                .as_path(),
-            &settings::Settings::for_rule(check_code),
+            &settings::Settings::for_rule(rule_code),
        )?;
-        insta::assert_yaml_snapshot!(snapshot, checks);
+        insta::assert_yaml_snapshot!(snapshot, diagnostics);
        Ok(())
    }
 }
@@ -67,10 +67,10 @@ mod tests {

    # Add the plugin to `lib.rs`.
    with open(os.path.join(ROOT_DIR, "src/lib.rs"), "a") as fp:
-        fp.write(f"pub mod {dir_name(plugin)};")
+        fp.write(f"mod {dir_name(plugin)};")

    # Add the relevant sections to `src/registry.rs`.
-    with open(os.path.join(ROOT_DIR, "src/registry.rs"), "r") as fp:
+    with open(os.path.join(ROOT_DIR, "src/registry.rs")) as fp:
        content = fp.read()

    with open(os.path.join(ROOT_DIR, "src/registry.rs"), "w") as fp:
@@ -85,23 +85,37 @@ mod tests {
                fp.write(f"{indent}{pascal_case(plugin)},")
                fp.write("\n")

-            elif line.strip() == 'CheckCategory::Ruff => "Ruff-specific rules",':
-                indent = line.split('CheckCategory::Ruff => "Ruff-specific rules",')[0]
-                fp.write(f'{indent}CheckCategory::{pascal_case(plugin)} => "{plugin}",')
+            elif line.strip() == 'RuleOrigin::Ruff => "Ruff-specific rules",':
+                indent = line.split('RuleOrigin::Ruff => "Ruff-specific rules",')[0]
+                fp.write(f'{indent}RuleOrigin::{pascal_case(plugin)} => "{plugin}",')
                fp.write("\n")

-            elif line.strip() == "CheckCategory::Ruff => vec![CheckCodePrefix::RUF],":
-                indent = line.split("CheckCategory::Ruff => vec![CheckCodePrefix::RUF],")[0]
+            elif line.strip() == "RuleOrigin::Ruff => vec![RuleCodePrefix::RUF],":
+                indent = line.split("RuleOrigin::Ruff => vec![RuleCodePrefix::RUF],")[0]
                fp.write(
-                    f"{indent}CheckCategory::{pascal_case(plugin)} => vec![\n"
+                    f"{indent}RuleOrigin::{pascal_case(plugin)} => vec![\n"
                    f'{indent}    todo!("Fill-in prefix after generating codes")\n'
                    f"{indent}],"
                )
                fp.write("\n")

-            elif line.strip() == "CheckCategory::Ruff => None,":
-                indent = line.split("CheckCategory::Ruff => None,")[0]
-                fp.write(f"{indent}CheckCategory::{pascal_case(plugin)} => " f'Some(("{url}", &Platform::PyPI)),')
+            elif line.strip() == "RuleOrigin::Ruff => None,":
+                indent = line.split("RuleOrigin::Ruff => None,")[0]
+                fp.write(f"{indent}RuleOrigin::{pascal_case(plugin)} => " f'Some(("{url}", &Platform::PyPI)),')
+                fp.write("\n")
+
+            fp.write(line)
+            fp.write("\n")
+
+    # Add the relevant section to `src/violations.rs`.
+    with open(os.path.join(ROOT_DIR, "src/violations.rs")) as fp:
+        content = fp.read()
+
+    with open(os.path.join(ROOT_DIR, "src/violations.rs"), "w") as fp:
+        for line in content.splitlines():
+            if line.strip() == "// Ruff":
+                indent = line.split("// Ruff")[0]
+                fp.write(f"{indent}// {plugin}")
                fp.write("\n")

            fp.write(line)
@@ -110,7 +124,7 @@ mod tests {

 if __name__ == "__main__":
    parser = argparse.ArgumentParser(
-        description="Generate boilerplate for a new plugin.",
+        description="Generate boilerplate for a new Flake8 plugin.",
        epilog=(
            "Example usage: python scripts/add_plugin.py flake8-pie "
            "--url https://pypi.org/project/flake8-pie/0.16.0/"
@@ -118,7 +132,6 @@ if __name__ == "__main__":
    )
    parser.add_argument(
        "plugin",
-        required=True,
        type=str,
        help="The name of the plugin to generate.",
    )
--- a/scripts/add_rule.py
+++ b/scripts/add_rule.py
@@ -0,0 +1,145 @@
+#!/usr/bin/env python3
+"""Generate boilerplate for a new rule.
+
+Example usage:
+
+    python scripts/add_rule.py \
+        --name PreferListBuiltin \
+        --code PIE807 \
+        --origin flake8-pie
+"""
+
+import argparse
+import os
+
+ROOT_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+
+
+def dir_name(origin: str) -> str:
+    return origin.replace("-", "_")
+
+
+def pascal_case(origin: str) -> str:
+    """Convert from snake-case to PascalCase."""
+    return "".join(word.title() for word in origin.split("-"))
+
+
+def snake_case(name: str) -> str:
+    """Convert from PascalCase to snake_case."""
+    return "".join(f"_{word.lower()}" if word.isupper() else word for word in name).lstrip("_")
+
+
+def main(*, name: str, code: str, origin: str) -> None:
+    # Create a test fixture.
+    with open(
+        os.path.join(ROOT_DIR, f"resources/test/fixtures/{dir_name(origin)}/{code}.py"),
+        "a",
+    ):
+        pass
+
+    # Add the relevant `#testcase` macro.
+    with open(os.path.join(ROOT_DIR, f"src/{dir_name(origin)}/mod.rs")) as fp:
+        content = fp.read()
+
+    with open(os.path.join(ROOT_DIR, f"src/{dir_name(origin)}/mod.rs"), "w") as fp:
+        for line in content.splitlines():
+            if line.strip() == "fn rules(rule_code: RuleCode, path: &Path) -> Result<()> {":
+                indent = line.split("fn rules(rule_code: RuleCode, path: &Path) -> Result<()> {")[0]
+                fp.write(f'{indent}#[test_case(RuleCode::{code}, Path::new("{code}.py"); "{code}")]')
+                fp.write("\n")
+
+            fp.write(line)
+            fp.write("\n")
+
+    # Add the relevant rule function.
+    with open(os.path.join(ROOT_DIR, f"src/{dir_name(origin)}/rules.rs"), "a") as fp:
+        fp.write(
+            f"""
+/// {code}
+pub fn {snake_case(name)}(checker: &mut Checker) {{}}
+"""
+        )
+        fp.write("\n")
+
+    # Add the relevant struct to `src/violations.rs`.
+    with open(os.path.join(ROOT_DIR, "src/violations.rs")) as fp:
+        content = fp.read()
+
+    with open(os.path.join(ROOT_DIR, "src/violations.rs"), "w") as fp:
+        for line in content.splitlines():
+            fp.write(line)
+            fp.write("\n")
+
+            if line.startswith(f"// {origin}"):
+                fp.write(
+                    """define_violation!(
+    pub struct %s;
+);
+impl Violation for %s {
+    fn message(&self) -> String {
+        todo!("Implement message")
+    }
+
+    fn placeholder() -> Self {
+        %s
+    }
+}
+"""
+                    % (name, name, name)
+                )
+                fp.write("\n")
+
+    # Add the relevant code-to-violation pair to `src/registry.rs`.
+    with open(os.path.join(ROOT_DIR, "src/registry.rs")) as fp:
+        content = fp.read()
+
+    seen_macro = False
+    has_written = False
+    with open(os.path.join(ROOT_DIR, "src/registry.rs"), "w") as fp:
+        for line in content.splitlines():
+            fp.write(line)
+            fp.write("\n")
+
+            if has_written:
+                continue
+
+            if line.startswith("define_rule_mapping!"):
+                seen_macro = True
+                continue
+
+            if not seen_macro:
+                continue
+
+            if line.strip() == f"// {origin}":
+                indent = line.split("//")[0]
+                fp.write(f"{indent}{code} => violations::{name},")
+                fp.write("\n")
+                has_written = True
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(
+        description="Generate boilerplate for a new rule.",
+        epilog="python scripts/add_rule.py --name PreferListBuiltin --code PIE807 --origin flake8-pie",
+    )
+    parser.add_argument(
+        "--name",
+        type=str,
+        required=True,
+        help="The name of the check to generate, in PascalCase (e.g., 'LineTooLong').",
+    )
+    parser.add_argument(
+        "--code",
+        type=str,
+        required=True,
+        help="The code of the check to generate (e.g., 'A001').",
+    )
+    parser.add_argument(
+        "--origin",
+        type=str,
+        required=True,
+        help="The source with which the check originated (e.g., 'flake8-builtins').",
+    )
+    args = parser.parse_args()
+
+    main(name=args.name, code=args.code, origin=args.origin)
--- a/src/ast/cast.rs
+++ b/src/ast/cast.rs
@@ -1,5 +1,12 @@
 use rustpython_ast::{Expr, Stmt, StmtKind};

+pub fn name(stmt: &Stmt) -> &str {
+    match &stmt.node {
+        StmtKind::FunctionDef { name, .. } | StmtKind::AsyncFunctionDef { name, .. } => name,
+        _ => panic!("Expected StmtKind::FunctionDef | StmtKind::AsyncFunctionDef"),
+    }
+}
+
 pub fn decorator_list(stmt: &Stmt) -> &Vec<Expr> {
    match &stmt.node {
        StmtKind::FunctionDef { decorator_list, .. }
--- a/src/ast/comparable.rs
+++ b/src/ast/comparable.rs
@@ -388,6 +388,12 @@ impl<'a> From<&'a Box<Expr>> for Box<ComparableExpr<'a>> {
    }
 }

+impl<'a> From<&'a Box<Expr>> for ComparableExpr<'a> {
+    fn from(expr: &'a Box<Expr>) -> Self {
+        (&**expr).into()
+    }
+}
+
 impl<'a> From<&'a Expr> for ComparableExpr<'a> {
    fn from(expr: &'a Expr) -> Self {
        match &expr.node {
--- a/src/ast/function_type.rs
+++ b/src/ast/function_type.rs
@@ -1,10 +1,8 @@
-use rustc_hash::{FxHashMap, FxHashSet};
 use rustpython_ast::Expr;

-use crate::ast::helpers::{
-    collect_call_paths, dealias_call_path, match_call_path, to_module_and_member,
-};
+use crate::ast::helpers::to_call_path;
 use crate::ast::types::{Scope, ScopeKind};
+use crate::checkers::ast::Checker;

 const CLASS_METHODS: [&str; 3] = ["__new__", "__init_subclass__", "__class_getitem__"];
 const METACLASS_BASES: [(&str, &str); 2] = [("", "type"), ("abc", "ABCMeta")];
@@ -18,11 +16,10 @@ pub enum FunctionType {

 /// Classify a function based on its scope, name, and decorators.
 pub fn classify(
+    checker: &Checker,
    scope: &Scope,
    name: &str,
    decorator_list: &[Expr],
-    from_imports: &FxHashMap<&str, FxHashSet<&str>>,
-    import_aliases: &FxHashMap<&str, &str>,
    classmethod_decorators: &[String],
    staticmethod_decorators: &[String],
 ) -> FunctionType {
@@ -33,17 +30,18 @@ pub fn classify(
    if CLASS_METHODS.contains(&name)
        || scope.bases.iter().any(|expr| {
            // The class itself extends a known metaclass, so all methods are class methods.
-            let call_path = dealias_call_path(collect_call_paths(expr), import_aliases);
-            METACLASS_BASES
-                .iter()
-                .any(|(module, member)| match_call_path(&call_path, module, member, from_imports))
+            checker.resolve_call_path(expr).map_or(false, |call_path| {
+                METACLASS_BASES
+                    .iter()
+                    .any(|(module, member)| call_path == [*module, *member])
+            })
        })
        || decorator_list.iter().any(|expr| {
            // The method is decorated with a class method decorator (like `@classmethod`).
-            let call_path = dealias_call_path(collect_call_paths(expr), import_aliases);
-            classmethod_decorators.iter().any(|decorator| {
-                let (module, member) = to_module_and_member(decorator);
-                match_call_path(&call_path, module, member, from_imports)
+            checker.resolve_call_path(expr).map_or(false, |call_path| {
+                classmethod_decorators
+                    .iter()
+                    .any(|decorator| call_path == to_call_path(decorator))
            })
        })
    {
@@ -51,10 +49,10 @@ pub fn classify(
    } else if decorator_list.iter().any(|expr| {
        // The method is decorated with a static method decorator (like
        // `@staticmethod`).
-        let call_path = dealias_call_path(collect_call_paths(expr), import_aliases);
-        staticmethod_decorators.iter().any(|decorator| {
-            let (module, member) = to_module_and_member(decorator);
-            match_call_path(&call_path, module, member, from_imports)
+        checker.resolve_call_path(expr).map_or(false, |call_path| {
+            staticmethod_decorators
+                .iter()
+                .any(|decorator| call_path == to_call_path(decorator))
        })
    }) {
        FunctionType::StaticMethod
--- a/src/ast/helpers.rs
+++ b/src/ast/helpers.rs
@@ -12,9 +12,8 @@ use rustpython_parser::lexer::Tok;
 use rustpython_parser::token::StringKind;

 use crate::ast::types::{Binding, BindingKind, Range};
-use crate::source_code_generator::SourceCodeGenerator;
-use crate::source_code_style::SourceCodeStyleDetector;
-use crate::SourceCodeLocator;
+use crate::checkers::ast::Checker;
+use crate::source_code::{Generator, Locator, Stylist};

 /// Create an `Expr` with default location from an `ExprKind`.
 pub fn create_expr(node: ExprKind) -> Expr {
@@ -27,15 +26,15 @@ pub fn create_stmt(node: StmtKind) -> Stmt {
 }

 /// Generate source code from an `Expr`.
-pub fn unparse_expr(expr: &Expr, stylist: &SourceCodeStyleDetector) -> String {
-    let mut generator: SourceCodeGenerator = stylist.into();
+pub fn unparse_expr(expr: &Expr, stylist: &Stylist) -> String {
+    let mut generator: Generator = stylist.into();
    generator.unparse_expr(expr, 0);
    generator.generate()
 }

 /// Generate source code from an `Stmt`.
-pub fn unparse_stmt(stmt: &Stmt, stylist: &SourceCodeStyleDetector) -> String {
-    let mut generator: SourceCodeGenerator = stylist.into();
+pub fn unparse_stmt(stmt: &Stmt, stylist: &Stylist) -> String {
+    let mut generator: Generator = stylist.into();
    generator.unparse_stmt(stmt);
    generator.generate()
 }
@@ -56,126 +55,143 @@ fn collect_call_path_inner<'a>(expr: &'a Expr, parts: &mut Vec<&'a str>) {
    }
 }

-/// Convert an `Expr` to its call path (like `List`, or `typing.List`).
-pub fn compose_call_path(expr: &Expr) -> Option<String> {
-    let segments = collect_call_paths(expr);
-    if segments.is_empty() {
-        None
-    } else {
-        Some(segments.join("."))
-    }
-}
-
 /// Convert an `Expr` to its call path segments (like ["typing", "List"]).
-pub fn collect_call_paths(expr: &Expr) -> Vec<&str> {
+pub fn collect_call_path(expr: &Expr) -> Vec<&str> {
    let mut segments = vec![];
    collect_call_path_inner(expr, &mut segments);
    segments
 }

-/// Rewrite any import aliases on a call path.
-pub fn dealias_call_path<'a>(
-    call_path: Vec<&'a str>,
-    import_aliases: &FxHashMap<&str, &'a str>,
-) -> Vec<&'a str> {
-    if let Some(head) = call_path.first() {
-        if let Some(origin) = import_aliases.get(head) {
-            let tail = &call_path[1..];
-            let mut call_path: Vec<&str> = vec![];
-            call_path.extend(origin.split('.'));
-            call_path.extend(tail);
-            call_path
-        } else {
-            call_path
-        }
+/// Convert an `Expr` to its call path (like `List`, or `typing.List`).
+pub fn compose_call_path(expr: &Expr) -> Option<String> {
+    let call_path = collect_call_path(expr);
+    if call_path.is_empty() {
+        None
    } else {
-        call_path
+        Some(format_call_path(&call_path))
    }
 }

-/// Return `true` if the `Expr` is a reference to `${module}.${target}`.
-///
-/// Useful for, e.g., ensuring that a `Union` reference represents
-/// `typing.Union`.
-pub fn match_module_member(
-    expr: &Expr,
-    module: &str,
-    member: &str,
-    from_imports: &FxHashMap<&str, FxHashSet<&str>>,
-    import_aliases: &FxHashMap<&str, &str>,
-) -> bool {
-    match_call_path(
-        &dealias_call_path(collect_call_paths(expr), import_aliases),
-        module,
-        member,
-        from_imports,
-    )
+/// Format a call path for display.
+pub fn format_call_path(call_path: &[&str]) -> String {
+    if call_path
+        .first()
+        .expect("Unable to format empty call path")
+        .is_empty()
+    {
+        call_path[1..].join(".")
+    } else {
+        call_path.join(".")
+    }
 }

-/// Return `true` if the `call_path` is a reference to `${module}.${target}`.
-///
-/// Optimized version of `match_module_member` for pre-computed call paths.
-pub fn match_call_path(
-    call_path: &[&str],
-    module: &str,
-    member: &str,
-    from_imports: &FxHashMap<&str, FxHashSet<&str>>,
-) -> bool {
-    // If we have no segments, we can't ever match.
-    let num_segments = call_path.len();
-    if num_segments == 0 {
-        return false;
+/// Return `true` if the `Expr` contains a reference to `${module}.${target}`.
+pub fn contains_call_path(checker: &Checker, expr: &Expr, target: &[&str]) -> bool {
+    any_over_expr(expr, &|expr| {
+        checker
+            .resolve_call_path(expr)
+            .map_or(false, |call_path| call_path == target)
+    })
+}
+
+/// Call `func` over every `Expr` in `expr`, returning `true` if any expression
+/// returns `true`..
+pub fn any_over_expr<F>(expr: &Expr, func: &F) -> bool
+where
+    F: Fn(&Expr) -> bool,
+{
+    if func(expr) {
+        return true;
    }
-
-    // If the last segment doesn't match the member, we can't ever match.
-    if call_path[num_segments - 1] != member {
-        return false;
-    }
-
-    // We now only need the module path, so throw out the member name.
-    let call_path = &call_path[..num_segments - 1];
-    let num_segments = call_path.len();
-
-    // Case (1): It's a builtin (like `list`).
-    // Case (2a): We imported from the parent (`from typing.re import Match`,
-    // `Match`).
-    // Case (2b): We imported star from the parent (`from typing.re import *`,
-    // `Match`).
-    if num_segments == 0 {
-        module.is_empty()
-            || from_imports.get(module).map_or(false, |imports| {
-                imports.contains(member) || imports.contains("*")
-            })
-    } else {
-        let components: Vec<&str> = module.split('.').collect();
-
-        // Case (3a): it's a fully qualified call path (`import typing`,
-        // `typing.re.Match`). Case (3b): it's a fully qualified call path (`import
-        // typing.re`, `typing.re.Match`).
-        if components == call_path {
-            return true;
+    match &expr.node {
+        ExprKind::BoolOp { values, .. } | ExprKind::JoinedStr { values } => {
+            values.iter().any(|expr| any_over_expr(expr, func))
        }
-
-        // Case (4): We imported from the grandparent (`from typing import re`,
-        // `re.Match`)
-        let num_matches = (0..components.len())
-            .take(num_segments)
-            .take_while(|i| components[components.len() - 1 - i] == call_path[num_segments - 1 - i])
-            .count();
-        if num_matches > 0 {
-            let cut = components.len() - num_matches;
-            // TODO(charlie): Rewrite to avoid this allocation.
-            let module = components[..cut].join(".");
-            let member = components[cut];
-            if from_imports
-                .get(&module.as_str())
-                .map_or(false, |imports| imports.contains(member))
-            {
-                return true;
-            }
+        ExprKind::NamedExpr { target, value } => {
+            any_over_expr(target, func) || any_over_expr(value, func)
        }
-
-        false
+        ExprKind::BinOp { left, right, .. } => {
+            any_over_expr(left, func) || any_over_expr(right, func)
+        }
+        ExprKind::UnaryOp { operand, .. } => any_over_expr(operand, func),
+        ExprKind::Lambda { body, .. } => any_over_expr(body, func),
+        ExprKind::IfExp { test, body, orelse } => {
+            any_over_expr(test, func) || any_over_expr(body, func) || any_over_expr(orelse, func)
+        }
+        ExprKind::Dict { keys, values } => values
+            .iter()
+            .chain(keys.iter())
+            .any(|expr| any_over_expr(expr, func)),
+        ExprKind::Set { elts } | ExprKind::List { elts, .. } | ExprKind::Tuple { elts, .. } => {
+            elts.iter().any(|expr| any_over_expr(expr, func))
+        }
+        ExprKind::ListComp { elt, generators }
+        | ExprKind::SetComp { elt, generators }
+        | ExprKind::GeneratorExp { elt, generators } => {
+            any_over_expr(elt, func)
+                || generators.iter().any(|generator| {
+                    any_over_expr(&generator.target, func)
+                        || any_over_expr(&generator.iter, func)
+                        || generator.ifs.iter().any(|expr| any_over_expr(expr, func))
+                })
+        }
+        ExprKind::DictComp {
+            key,
+            value,
+            generators,
+        } => {
+            any_over_expr(key, func)
+                || any_over_expr(value, func)
+                || generators.iter().any(|generator| {
+                    any_over_expr(&generator.target, func)
+                        || any_over_expr(&generator.iter, func)
+                        || generator.ifs.iter().any(|expr| any_over_expr(expr, func))
+                })
+        }
+        ExprKind::Await { value }
+        | ExprKind::YieldFrom { value }
+        | ExprKind::Attribute { value, .. }
+        | ExprKind::Starred { value, .. } => any_over_expr(value, func),
+        ExprKind::Yield { value } => value
+            .as_ref()
+            .map_or(false, |value| any_over_expr(value, func)),
+        ExprKind::Compare {
+            left, comparators, ..
+        } => any_over_expr(left, func) || comparators.iter().any(|expr| any_over_expr(expr, func)),
+        ExprKind::Call {
+            func: call_func,
+            args,
+            keywords,
+        } => {
+            any_over_expr(call_func, func)
+                || args.iter().any(|expr| any_over_expr(expr, func))
+                || keywords
+                    .iter()
+                    .any(|keyword| any_over_expr(&keyword.node.value, func))
+        }
+        ExprKind::FormattedValue {
+            value, format_spec, ..
+        } => {
+            any_over_expr(value, func)
+                || format_spec
+                    .as_ref()
+                    .map_or(false, |value| any_over_expr(value, func))
+        }
+        ExprKind::Subscript { value, slice, .. } => {
+            any_over_expr(value, func) || any_over_expr(slice, func)
+        }
+        ExprKind::Slice { lower, upper, step } => {
+            lower
+                .as_ref()
+                .map_or(false, |value| any_over_expr(value, func))
+                || upper
+                    .as_ref()
+                    .map_or(false, |value| any_over_expr(value, func))
+                || step
+                    .as_ref()
+                    .map_or(false, |value| any_over_expr(value, func))
+        }
+        ExprKind::Name { .. } | ExprKind::Constant { .. } => false,
    }
 }

@@ -191,12 +207,12 @@ pub fn is_assignment_to_a_dunder(stmt: &Stmt) -> bool {
                return false;
            }
            match &targets[0].node {
-                ExprKind::Name { id, ctx: _ } => DUNDER_REGEX.is_match(id),
+                ExprKind::Name { id, .. } => DUNDER_REGEX.is_match(id),
                _ => false,
            }
        }
        StmtKind::AnnAssign { target, .. } => match &target.node {
-            ExprKind::Name { id, ctx: _ } => DUNDER_REGEX.is_match(id),
+            ExprKind::Name { id, .. } => DUNDER_REGEX.is_match(id),
            _ => false,
        },
        _ => false,
@@ -266,13 +282,13 @@ pub fn extract_handler_names(handlers: &[Excepthandler]) -> Vec<Vec<&str>> {
                if let Some(type_) = type_ {
                    if let ExprKind::Tuple { elts, .. } = &type_.node {
                        for type_ in elts {
-                            let call_path = collect_call_paths(type_);
+                            let call_path = collect_call_path(type_);
                            if !call_path.is_empty() {
                                handler_names.push(call_path);
                            }
                        }
                    } else {
-                        let call_path = collect_call_paths(type_);
+                        let call_path = collect_call_path(type_);
                        if !call_path.is_empty() {
                            handler_names.push(call_path);
                        }
@@ -305,6 +321,13 @@ pub fn collect_arg_names<'a>(arguments: &'a Arguments) -> FxHashSet<&'a str> {
    arg_names
 }

+/// Returns `true` if a statement or expression includes at least one comment.
+pub fn has_comments<T>(located: &Located<T>, locator: &Locator) -> bool {
+    lexer::make_tokenizer(&locator.slice_source_code_range(&Range::from_located(located)))
+        .flatten()
+        .any(|(_, tok, _)| matches!(tok, Tok::Comment(..)))
+}
+
 /// Returns `true` if a call is an argumented `super` invocation.
 pub fn is_super_call_with_arguments(func: &Expr, args: &[Expr]) -> bool {
    if let ExprKind::Name { id, .. } = &func.node {
@@ -328,12 +351,37 @@ pub fn format_import_from(level: Option<&usize>, module: Option<&str>) -> String
    module_name
 }

+/// Format the member reference name for a relative import.
+pub fn format_import_from_member(
+    level: Option<&usize>,
+    module: Option<&str>,
+    member: &str,
+) -> String {
+    let mut full_name = String::with_capacity(
+        level.map_or(0, |level| *level)
+            + module.as_ref().map_or(0, |module| module.len())
+            + 1
+            + member.len(),
+    );
+    if let Some(level) = level {
+        for _ in 0..*level {
+            full_name.push('.');
+        }
+    }
+    if let Some(module) = module {
+        full_name.push_str(module);
+        full_name.push('.');
+    }
+    full_name.push_str(member);
+    full_name
+}
+
 /// Split a target string (like `typing.List`) into (`typing`, `List`).
-pub fn to_module_and_member(target: &str) -> (&str, &str) {
-    if let Some(index) = target.rfind('.') {
-        (&target[..index], &target[index + 1..])
+pub fn to_call_path(target: &str) -> Vec<&str> {
+    if target.contains('.') {
+        target.split('.').collect()
    } else {
-        ("", target)
+        vec!["", target]
    }
 }

@@ -351,14 +399,14 @@ pub fn to_absolute(relative: Location, base: Location) -> Location {
 }

 /// Return `true` if a `Stmt` has leading content.
-pub fn match_leading_content(stmt: &Stmt, locator: &SourceCodeLocator) -> bool {
+pub fn match_leading_content(stmt: &Stmt, locator: &Locator) -> bool {
    let range = Range::new(Location::new(stmt.location.row(), 0), stmt.location);
    let prefix = locator.slice_source_code_range(&range);
    prefix.chars().any(|char| !char.is_whitespace())
 }

 /// Return `true` if a `Stmt` has trailing content.
-pub fn match_trailing_content(stmt: &Stmt, locator: &SourceCodeLocator) -> bool {
+pub fn match_trailing_content(stmt: &Stmt, locator: &Locator) -> bool {
    let range = Range::new(
        stmt.end_location.unwrap(),
        Location::new(stmt.end_location.unwrap().row() + 1, 0),
@@ -376,7 +424,7 @@ pub fn match_trailing_content(stmt: &Stmt, locator: &SourceCodeLocator) -> bool
 }

 /// Return the number of trailing empty lines following a statement.
-pub fn count_trailing_lines(stmt: &Stmt, locator: &SourceCodeLocator) -> usize {
+pub fn count_trailing_lines(stmt: &Stmt, locator: &Locator) -> usize {
    let suffix =
        locator.slice_source_code_at(&Location::new(stmt.end_location.unwrap().row() + 1, 0));
    suffix
@@ -388,7 +436,7 @@ pub fn count_trailing_lines(stmt: &Stmt, locator: &SourceCodeLocator) -> usize {
 /// Return the appropriate visual `Range` for any message that spans a `Stmt`.
 /// Specifically, this method returns the range of a function or class name,
 /// rather than that of the entire function or class body.
-pub fn identifier_range(stmt: &Stmt, locator: &SourceCodeLocator) -> Range {
+pub fn identifier_range(stmt: &Stmt, locator: &Locator) -> Range {
    if matches!(
        stmt.node,
        StmtKind::ClassDef { .. }
@@ -407,7 +455,7 @@ pub fn identifier_range(stmt: &Stmt, locator: &SourceCodeLocator) -> Range {
 }

 /// Like `identifier_range`, but accepts a `Binding`.
-pub fn binding_range(binding: &Binding, locator: &SourceCodeLocator) -> Range {
+pub fn binding_range(binding: &Binding, locator: &Locator) -> Range {
    if matches!(
        binding.kind,
        BindingKind::ClassDefinition | BindingKind::FunctionDefinition
@@ -423,7 +471,7 @@ pub fn binding_range(binding: &Binding, locator: &SourceCodeLocator) -> Range {
 }

 // Return the ranges of `Name` tokens within a specified node.
-pub fn find_names<T>(located: &Located<T>, locator: &SourceCodeLocator) -> Vec<Range> {
+pub fn find_names<T>(located: &Located<T>, locator: &Locator) -> Vec<Range> {
    let contents = locator.slice_source_code_range(&Range::from_located(located));
    lexer::make_tokenizer_located(&contents, located.location)
        .flatten()
@@ -436,10 +484,7 @@ pub fn find_names<T>(located: &Located<T>, locator: &SourceCodeLocator) -> Vec<R
 }

 /// Return the `Range` of `name` in `Excepthandler`.
-pub fn excepthandler_name_range(
-    handler: &Excepthandler,
-    locator: &SourceCodeLocator,
-) -> Option<Range> {
+pub fn excepthandler_name_range(handler: &Excepthandler, locator: &Locator) -> Option<Range> {
    let ExcepthandlerKind::ExceptHandler {
        name, type_, body, ..
    } = &handler.node;
@@ -462,7 +507,7 @@ pub fn excepthandler_name_range(
 }

 /// Return the `Range` of `except` in `Excepthandler`.
-pub fn except_range(handler: &Excepthandler, locator: &SourceCodeLocator) -> Range {
+pub fn except_range(handler: &Excepthandler, locator: &Locator) -> Range {
    let ExcepthandlerKind::ExceptHandler { body, type_, .. } = &handler.node;
    let end = if let Some(type_) = type_ {
        type_.location
@@ -487,7 +532,7 @@ pub fn except_range(handler: &Excepthandler, locator: &SourceCodeLocator) -> Ran
 }

 /// Find f-strings that don't contain any formatted values in a `JoinedStr`.
-pub fn find_useless_f_strings(expr: &Expr, locator: &SourceCodeLocator) -> Vec<(Range, Range)> {
+pub fn find_useless_f_strings(expr: &Expr, locator: &Locator) -> Vec<(Range, Range)> {
    let contents = locator.slice_source_code_range(&Range::from_located(expr));
    lexer::make_tokenizer_located(&contents, expr.location)
        .flatten()
@@ -524,7 +569,7 @@ pub fn find_useless_f_strings(expr: &Expr, locator: &SourceCodeLocator) -> Vec<(
 }

 /// Return the `Range` of `else` in `For`, `AsyncFor`, and `While` statements.
-pub fn else_range(stmt: &Stmt, locator: &SourceCodeLocator) -> Option<Range> {
+pub fn else_range(stmt: &Stmt, locator: &Locator) -> Option<Range> {
    match &stmt.node {
        StmtKind::For { body, orelse, .. }
        | StmtKind::AsyncFor { body, orelse, .. }
@@ -558,7 +603,7 @@ pub fn else_range(stmt: &Stmt, locator: &SourceCodeLocator) -> Option<Range> {

 /// Return `true` if a `Stmt` appears to be part of a multi-statement line, with
 /// other statements preceding it.
-pub fn preceded_by_continuation(stmt: &Stmt, locator: &SourceCodeLocator) -> bool {
+pub fn preceded_by_continuation(stmt: &Stmt, locator: &Locator) -> bool {
    // Does the previous line end in a continuation? This will have a specific
    // false-positive, which is that if the previous line ends in a comment, it
    // will be treated as a continuation. So we should only use this information to
@@ -579,16 +624,31 @@ pub fn preceded_by_continuation(stmt: &Stmt, locator: &SourceCodeLocator) -> boo

 /// Return `true` if a `Stmt` appears to be part of a multi-statement line, with
 /// other statements preceding it.
-pub fn preceded_by_multi_statement_line(stmt: &Stmt, locator: &SourceCodeLocator) -> bool {
+pub fn preceded_by_multi_statement_line(stmt: &Stmt, locator: &Locator) -> bool {
    match_leading_content(stmt, locator) || preceded_by_continuation(stmt, locator)
 }

 /// Return `true` if a `Stmt` appears to be part of a multi-statement line, with
 /// other statements following it.
-pub fn followed_by_multi_statement_line(stmt: &Stmt, locator: &SourceCodeLocator) -> bool {
+pub fn followed_by_multi_statement_line(stmt: &Stmt, locator: &Locator) -> bool {
    match_trailing_content(stmt, locator)
 }

+/// Return `true` if a `Stmt` is a docstring.
+pub fn is_docstring_stmt(stmt: &Stmt) -> bool {
+    if let StmtKind::Expr { value } = &stmt.node {
+        matches!(
+            value.node,
+            ExprKind::Constant {
+                value: Constant::Str { .. },
+                ..
+            }
+        )
+    } else {
+        false
+    }
+}
+
 #[derive(Default)]
 /// A simple representation of a call's positional and keyword arguments.
 pub struct SimpleCallArgs<'a> {
@@ -634,188 +694,48 @@ impl<'a> SimpleCallArgs<'a> {
        }
        None
    }
+
+    /// Get the number of positional and keyword arguments used.
+    #[allow(clippy::len_without_is_empty)]
+    pub fn len(&self) -> usize {
+        self.args.len() + self.kwargs.len()
+    }
 }

 #[cfg(test)]
 mod tests {
    use anyhow::Result;
-    use rustc_hash::{FxHashMap, FxHashSet};
    use rustpython_ast::Location;
    use rustpython_parser::parser;

-    use crate::ast::helpers::{
-        else_range, identifier_range, match_module_member, match_trailing_content,
-    };
+    use crate::ast::helpers::{else_range, identifier_range, match_trailing_content};
    use crate::ast::types::Range;
-    use crate::source_code_locator::SourceCodeLocator;
-
-    #[test]
-    fn builtin() -> Result<()> {
-        let expr = parser::parse_expression("list", "<filename>")?;
-        assert!(match_module_member(
-            &expr,
-            "",
-            "list",
-            &FxHashMap::default(),
-            &FxHashMap::default(),
-        ));
-        Ok(())
-    }
-
-    #[test]
-    fn fully_qualified() -> Result<()> {
-        let expr = parser::parse_expression("typing.re.Match", "<filename>")?;
-        assert!(match_module_member(
-            &expr,
-            "typing.re",
-            "Match",
-            &FxHashMap::default(),
-            &FxHashMap::default(),
-        ));
-        Ok(())
-    }
-
-    #[test]
-    fn unimported() -> Result<()> {
-        let expr = parser::parse_expression("Match", "<filename>")?;
-        assert!(!match_module_member(
-            &expr,
-            "typing.re",
-            "Match",
-            &FxHashMap::default(),
-            &FxHashMap::default(),
-        ));
-        let expr = parser::parse_expression("re.Match", "<filename>")?;
-        assert!(!match_module_member(
-            &expr,
-            "typing.re",
-            "Match",
-            &FxHashMap::default(),
-            &FxHashMap::default(),
-        ));
-        Ok(())
-    }
-
-    #[test]
-    fn from_star() -> Result<()> {
-        let expr = parser::parse_expression("Match", "<filename>")?;
-        assert!(match_module_member(
-            &expr,
-            "typing.re",
-            "Match",
-            &FxHashMap::from_iter([("typing.re", FxHashSet::from_iter(["*"]))]),
-            &FxHashMap::default()
-        ));
-        Ok(())
-    }
-
-    #[test]
-    fn from_parent() -> Result<()> {
-        let expr = parser::parse_expression("Match", "<filename>")?;
-        assert!(match_module_member(
-            &expr,
-            "typing.re",
-            "Match",
-            &FxHashMap::from_iter([("typing.re", FxHashSet::from_iter(["Match"]))]),
-            &FxHashMap::default()
-        ));
-        Ok(())
-    }
-
-    #[test]
-    fn from_grandparent() -> Result<()> {
-        let expr = parser::parse_expression("re.Match", "<filename>")?;
-        assert!(match_module_member(
-            &expr,
-            "typing.re",
-            "Match",
-            &FxHashMap::from_iter([("typing", FxHashSet::from_iter(["re"]))]),
-            &FxHashMap::default()
-        ));
-
-        let expr = parser::parse_expression("match.Match", "<filename>")?;
-        assert!(match_module_member(
-            &expr,
-            "typing.re.match",
-            "Match",
-            &FxHashMap::from_iter([("typing.re", FxHashSet::from_iter(["match"]))]),
-            &FxHashMap::default()
-        ));
-
-        let expr = parser::parse_expression("re.match.Match", "<filename>")?;
-        assert!(match_module_member(
-            &expr,
-            "typing.re.match",
-            "Match",
-            &FxHashMap::from_iter([("typing", FxHashSet::from_iter(["re"]))]),
-            &FxHashMap::default()
-        ));
-        Ok(())
-    }
-
-    #[test]
-    fn from_alias() -> Result<()> {
-        let expr = parser::parse_expression("IMatch", "<filename>")?;
-        assert!(match_module_member(
-            &expr,
-            "typing.re",
-            "Match",
-            &FxHashMap::from_iter([("typing.re", FxHashSet::from_iter(["Match"]))]),
-            &FxHashMap::from_iter([("IMatch", "Match")]),
-        ));
-        Ok(())
-    }
-
-    #[test]
-    fn from_aliased_parent() -> Result<()> {
-        let expr = parser::parse_expression("t.Match", "<filename>")?;
-        assert!(match_module_member(
-            &expr,
-            "typing.re",
-            "Match",
-            &FxHashMap::default(),
-            &FxHashMap::from_iter([("t", "typing.re")]),
-        ));
-        Ok(())
-    }
-
-    #[test]
-    fn from_aliased_grandparent() -> Result<()> {
-        let expr = parser::parse_expression("t.re.Match", "<filename>")?;
-        assert!(match_module_member(
-            &expr,
-            "typing.re",
-            "Match",
-            &FxHashMap::default(),
-            &FxHashMap::from_iter([("t", "typing")]),
-        ));
-        Ok(())
-    }
+    use crate::source_code::Locator;

    #[test]
    fn trailing_content() -> Result<()> {
        let contents = "x = 1";
        let program = parser::parse_program(contents, "<filename>")?;
        let stmt = program.first().unwrap();
-        let locator = SourceCodeLocator::new(contents);
+        let locator = Locator::new(contents);
        assert!(!match_trailing_content(stmt, &locator));

        let contents = "x = 1; y = 2";
        let program = parser::parse_program(contents, "<filename>")?;
        let stmt = program.first().unwrap();
-        let locator = SourceCodeLocator::new(contents);
+        let locator = Locator::new(contents);
        assert!(match_trailing_content(stmt, &locator));

        let contents = "x = 1  ";
        let program = parser::parse_program(contents, "<filename>")?;
        let stmt = program.first().unwrap();
-        let locator = SourceCodeLocator::new(contents);
+        let locator = Locator::new(contents);
        assert!(!match_trailing_content(stmt, &locator));

        let contents = "x = 1  # Comment";
        let program = parser::parse_program(contents, "<filename>")?;
        let stmt = program.first().unwrap();
-        let locator = SourceCodeLocator::new(contents);
+        let locator = Locator::new(contents);
        assert!(!match_trailing_content(stmt, &locator));

        let contents = r#"
@@ -825,7 +745,7 @@ y = 2
        .trim();
        let program = parser::parse_program(contents, "<filename>")?;
        let stmt = program.first().unwrap();
-        let locator = SourceCodeLocator::new(contents);
+        let locator = Locator::new(contents);
        assert!(!match_trailing_content(stmt, &locator));

        Ok(())
@@ -836,7 +756,7 @@ y = 2
        let contents = "def f(): pass".trim();
        let program = parser::parse_program(contents, "<filename>")?;
        let stmt = program.first().unwrap();
-        let locator = SourceCodeLocator::new(contents);
+        let locator = Locator::new(contents);
        assert_eq!(
            identifier_range(stmt, &locator),
            Range::new(Location::new(1, 4), Location::new(1, 5),)
@@ -850,7 +770,7 @@ def \
        .trim();
        let program = parser::parse_program(contents, "<filename>")?;
        let stmt = program.first().unwrap();
-        let locator = SourceCodeLocator::new(contents);
+        let locator = Locator::new(contents);
        assert_eq!(
            identifier_range(stmt, &locator),
            Range::new(Location::new(2, 2), Location::new(2, 3),)
@@ -859,7 +779,7 @@ def \
        let contents = "class Class(): pass".trim();
        let program = parser::parse_program(contents, "<filename>")?;
        let stmt = program.first().unwrap();
-        let locator = SourceCodeLocator::new(contents);
+        let locator = Locator::new(contents);
        assert_eq!(
            identifier_range(stmt, &locator),
            Range::new(Location::new(1, 6), Location::new(1, 11),)
@@ -868,7 +788,7 @@ def \
        let contents = "class Class: pass".trim();
        let program = parser::parse_program(contents, "<filename>")?;
        let stmt = program.first().unwrap();
-        let locator = SourceCodeLocator::new(contents);
+        let locator = Locator::new(contents);
        assert_eq!(
            identifier_range(stmt, &locator),
            Range::new(Location::new(1, 6), Location::new(1, 11),)
@@ -882,7 +802,7 @@ class Class():
        .trim();
        let program = parser::parse_program(contents, "<filename>")?;
        let stmt = program.first().unwrap();
-        let locator = SourceCodeLocator::new(contents);
+        let locator = Locator::new(contents);
        assert_eq!(
            identifier_range(stmt, &locator),
            Range::new(Location::new(2, 6), Location::new(2, 11),)
@@ -891,7 +811,7 @@ class Class():
        let contents = r#"x = y + 1"#.trim();
        let program = parser::parse_program(contents, "<filename>")?;
        let stmt = program.first().unwrap();
-        let locator = SourceCodeLocator::new(contents);
+        let locator = Locator::new(contents);
        assert_eq!(
            identifier_range(stmt, &locator),
            Range::new(Location::new(1, 0), Location::new(1, 9),)
@@ -911,7 +831,7 @@ else:
        .trim();
        let program = parser::parse_program(contents, "<filename>")?;
        let stmt = program.first().unwrap();
-        let locator = SourceCodeLocator::new(contents);
+        let locator = Locator::new(contents);
        let range = else_range(stmt, &locator).unwrap();
        assert_eq!(range.location.row(), 3);
        assert_eq!(range.location.column(), 0);
--- a/src/ast/operations.rs
+++ b/src/ast/operations.rs
@@ -4,6 +4,7 @@ use rustpython_parser::ast::{Constant, Expr, ExprKind, Stmt, StmtKind};
 use rustpython_parser::lexer;
 use rustpython_parser::lexer::Tok;

+use crate::ast::helpers::any_over_expr;
 use crate::ast::types::{Binding, BindingKind, Scope};
 use crate::ast::visitor;
 use crate::ast::visitor::Visitor;
@@ -129,76 +130,13 @@ pub fn in_nested_block<'a>(mut parents: impl Iterator<Item = &'a Stmt>) -> bool
    })
 }

-/// Returns `true` if `parent` contains `child`.
-fn contains(parent: &Expr, child: &Expr) -> bool {
-    match &parent.node {
-        ExprKind::BoolOp { values, .. } => values.iter().any(|parent| contains(parent, child)),
-        ExprKind::NamedExpr { target, value } => contains(target, child) || contains(value, child),
-        ExprKind::BinOp { left, right, .. } => contains(left, child) || contains(right, child),
-        ExprKind::UnaryOp { operand, .. } => contains(operand, child),
-        ExprKind::Lambda { body, .. } => contains(body, child),
-        ExprKind::IfExp { test, body, orelse } => {
-            contains(test, child) || contains(body, child) || contains(orelse, child)
-        }
-        ExprKind::Dict { keys, values } => keys
-            .iter()
-            .chain(values.iter())
-            .any(|parent| contains(parent, child)),
-        ExprKind::Set { elts } => elts.iter().any(|parent| contains(parent, child)),
-        ExprKind::ListComp { elt, .. } => contains(elt, child),
-        ExprKind::SetComp { elt, .. } => contains(elt, child),
-        ExprKind::DictComp { key, value, .. } => contains(key, child) || contains(value, child),
-        ExprKind::GeneratorExp { elt, .. } => contains(elt, child),
-        ExprKind::Await { value } => contains(value, child),
-        ExprKind::Yield { value } => value.as_ref().map_or(false, |value| contains(value, child)),
-        ExprKind::YieldFrom { value } => contains(value, child),
-        ExprKind::Compare {
-            left, comparators, ..
-        } => contains(left, child) || comparators.iter().any(|parent| contains(parent, child)),
-        ExprKind::Call {
-            func,
-            args,
-            keywords,
-        } => {
-            contains(func, child)
-                || args.iter().any(|parent| contains(parent, child))
-                || keywords
-                    .iter()
-                    .any(|keyword| contains(&keyword.node.value, child))
-        }
-        ExprKind::FormattedValue {
-            value, format_spec, ..
-        } => {
-            contains(value, child)
-                || format_spec
-                    .as_ref()
-                    .map_or(false, |value| contains(value, child))
-        }
-        ExprKind::JoinedStr { values } => values.iter().any(|parent| contains(parent, child)),
-        ExprKind::Constant { .. } => false,
-        ExprKind::Attribute { value, .. } => contains(value, child),
-        ExprKind::Subscript { value, slice, .. } => {
-            contains(value, child) || contains(slice, child)
-        }
-        ExprKind::Starred { value, .. } => contains(value, child),
-        ExprKind::Name { .. } => parent == child,
-        ExprKind::List { elts, .. } => elts.iter().any(|parent| contains(parent, child)),
-        ExprKind::Tuple { elts, .. } => elts.iter().any(|parent| contains(parent, child)),
-        ExprKind::Slice { lower, upper, step } => {
-            lower.as_ref().map_or(false, |value| contains(value, child))
-                || upper.as_ref().map_or(false, |value| contains(value, child))
-                || step.as_ref().map_or(false, |value| contains(value, child))
-        }
-    }
-}
-
 /// Check if a node represents an unpacking assignment.
 pub fn is_unpacking_assignment(parent: &Stmt, child: &Expr) -> bool {
    match &parent.node {
        StmtKind::With { items, .. } => items.iter().any(|item| {
            if let Some(optional_vars) = &item.optional_vars {
                if matches!(optional_vars.node, ExprKind::Tuple { .. }) {
-                    if contains(optional_vars, child) {
+                    if any_over_expr(optional_vars, &|expr| expr == child) {
                        return true;
                    }
                }
@@ -227,7 +165,7 @@ pub fn is_unpacking_assignment(parent: &Stmt, child: &Expr) -> bool {
                    matches!(
                        item.node,
                        ExprKind::Set { .. } | ExprKind::List { .. } | ExprKind::Tuple { .. }
-                    ) && contains(item, child)
+                    ) && any_over_expr(item, &|expr| expr == child)
                });

            // If our child is a tuple, and value is not, it's always an unpacking
--- a/src/ast/types.rs
+++ b/src/ast/types.rs
@@ -74,7 +74,6 @@ pub enum ScopeKind<'a> {
    Function(FunctionDef<'a>),
    Generator,
    Module,
-    Arg,
    Lambda(Lambda<'a>),
 }

@@ -105,7 +104,7 @@ impl<'a> Scope<'a> {
 }

 #[derive(Clone, Debug)]
-pub enum BindingKind {
+pub enum BindingKind<'a> {
    Annotation,
    Argument,
    Assignment,
@@ -119,14 +118,14 @@ pub enum BindingKind {
    Export(Vec<String>),
    FutureImportation,
    StarImportation(Option<usize>, Option<String>),
-    Importation(String, String),
-    FromImportation(String, String),
-    SubmoduleImportation(String, String),
+    Importation(&'a str, &'a str),
+    FromImportation(&'a str, String),
+    SubmoduleImportation(&'a str, &'a str),
 }

 #[derive(Clone, Debug)]
 pub struct Binding<'a> {
-    pub kind: BindingKind,
+    pub kind: BindingKind<'a>,
    pub range: Range,
    /// The statement in which the `Binding` was defined.
    pub source: Option<RefEquality<'a, Stmt>>,
@@ -169,19 +168,26 @@ impl<'a> Binding<'a> {

    pub fn redefines(&self, existing: &'a Binding) -> bool {
        match &self.kind {
-            BindingKind::Importation(_, full_name) | BindingKind::FromImportation(_, full_name) => {
-                if let BindingKind::SubmoduleImportation(_, existing_full_name) = &existing.kind {
-                    return full_name == existing_full_name;
+            BindingKind::Importation(.., full_name) => {
+                if let BindingKind::SubmoduleImportation(.., existing) = &existing.kind {
+                    return full_name == existing;
                }
            }
-            BindingKind::SubmoduleImportation(_, full_name) => {
-                if let BindingKind::Importation(_, existing_full_name)
-                | BindingKind::FromImportation(_, existing_full_name)
-                | BindingKind::SubmoduleImportation(_, existing_full_name) = &existing.kind
-                {
-                    return full_name == existing_full_name;
+            BindingKind::FromImportation(.., full_name) => {
+                if let BindingKind::SubmoduleImportation(.., existing) = &existing.kind {
+                    return full_name == existing;
                }
            }
+            BindingKind::SubmoduleImportation(.., full_name) => match &existing.kind {
+                BindingKind::Importation(.., existing)
+                | BindingKind::SubmoduleImportation(.., existing) => {
+                    return full_name == existing;
+                }
+                BindingKind::FromImportation(.., existing) => {
+                    return full_name == existing;
+                }
+                _ => {}
+            },
            BindingKind::Annotation => {
                return false;
            }
--- a/src/autofix/fixer.rs
+++ b/src/autofix/fixer.rs
@@ -1,225 +1 @@
-use std::borrow::Cow;
-use std::collections::BTreeSet;

-use itertools::Itertools;
-use ropey::RopeBuilder;
-use rustpython_parser::ast::Location;
-
-use crate::ast::types::Range;
-use crate::autofix::Fix;
-use crate::registry::Check;
-use crate::source_code_locator::SourceCodeLocator;
-
-#[derive(Debug, Copy, Clone, Hash)]
-pub enum Mode {
-    Generate,
-    Apply,
-    Diff,
-    None,
-}
-
-impl From<bool> for Mode {
-    fn from(value: bool) -> Self {
-        if value {
-            Mode::Apply
-        } else {
-            Mode::None
-        }
-    }
-}
-
-/// Auto-fix errors in a file, and write the fixed source code to disk.
-pub fn fix_file<'a>(
-    checks: &'a [Check],
-    locator: &'a SourceCodeLocator<'a>,
-) -> Option<(Cow<'a, str>, usize)> {
-    if checks.iter().all(|check| check.fix.is_none()) {
-        return None;
-    }
-
-    Some(apply_fixes(
-        checks.iter().filter_map(|check| check.fix.as_ref()),
-        locator,
-    ))
-}
-
-/// Apply a series of fixes.
-fn apply_fixes<'a>(
-    fixes: impl Iterator<Item = &'a Fix>,
-    locator: &'a SourceCodeLocator<'a>,
-) -> (Cow<'a, str>, usize) {
-    let mut output = RopeBuilder::new();
-    let mut last_pos: Location = Location::new(1, 0);
-    let mut applied: BTreeSet<&Fix> = BTreeSet::default();
-    let mut num_fixed: usize = 0;
-
-    for fix in fixes.sorted_by_key(|fix| fix.location) {
-        // If we already applied an identical fix as part of another correction, skip
-        // any re-application.
-        if applied.contains(&fix) {
-            num_fixed += 1;
-            continue;
-        }
-
-        // Best-effort approach: if this fix overlaps with a fix we've already applied,
-        // skip it.
-        if last_pos > fix.location {
-            continue;
-        }
-
-        // Add all contents from `last_pos` to `fix.location`.
-        let slice = locator.slice_source_code_range(&Range::new(last_pos, fix.location));
-        output.append(&slice);
-
-        // Add the patch itself.
-        output.append(&fix.content);
-
-        // Track that the fix was applied.
-        last_pos = fix.end_location;
-        applied.insert(fix);
-        num_fixed += 1;
-    }
-
-    // Add the remaining content.
-    let slice = locator.slice_source_code_at(&last_pos);
-    output.append(&slice);
-
-    (Cow::from(output.finish()), num_fixed)
-}
-
-#[cfg(test)]
-mod tests {
-    use rustpython_parser::ast::Location;
-
-    use crate::autofix::fixer::apply_fixes;
-    use crate::autofix::Fix;
-    use crate::SourceCodeLocator;
-
-    #[test]
-    fn empty_file() {
-        let fixes = vec![];
-        let locator = SourceCodeLocator::new(r#""#);
-        let (contents, fixed) = apply_fixes(fixes.iter(), &locator);
-        assert_eq!(contents, "");
-        assert_eq!(fixed, 0);
-    }
-
-    #[test]
-    fn apply_single_replacement() {
-        let fixes = vec![Fix {
-            content: "Bar".to_string(),
-            location: Location::new(1, 8),
-            end_location: Location::new(1, 14),
-        }];
-        let locator = SourceCodeLocator::new(
-            r#"
-class A(object):
-    ...
-"#
-            .trim(),
-        );
-        let (contents, fixed) = apply_fixes(fixes.iter(), &locator);
-        assert_eq!(
-            contents,
-            r#"
-class A(Bar):
-    ...
-"#
-            .trim(),
-        );
-        assert_eq!(fixed, 1);
-    }
-
-    #[test]
-    fn apply_single_removal() {
-        let fixes = vec![Fix {
-            content: String::new(),
-            location: Location::new(1, 7),
-            end_location: Location::new(1, 15),
-        }];
-        let locator = SourceCodeLocator::new(
-            r#"
-class A(object):
-    ...
-"#
-            .trim(),
-        );
-        let (contents, fixed) = apply_fixes(fixes.iter(), &locator);
-        assert_eq!(
-            contents,
-            r#"
-class A:
-    ...
-"#
-            .trim()
-        );
-        assert_eq!(fixed, 1);
-    }
-
-    #[test]
-    fn apply_double_removal() {
-        let fixes = vec![
-            Fix {
-                content: String::new(),
-                location: Location::new(1, 7),
-                end_location: Location::new(1, 16),
-            },
-            Fix {
-                content: String::new(),
-                location: Location::new(1, 16),
-                end_location: Location::new(1, 23),
-            },
-        ];
-        let locator = SourceCodeLocator::new(
-            r#"
-class A(object, object):
-    ...
-"#
-            .trim(),
-        );
-        let (contents, fixed) = apply_fixes(fixes.iter(), &locator);
-
-        assert_eq!(
-            contents,
-            r#"
-class A:
-    ...
-"#
-            .trim()
-        );
-        assert_eq!(fixed, 2);
-    }
-
-    #[test]
-    fn ignore_overlapping_fixes() {
-        let fixes = vec![
-            Fix {
-                content: String::new(),
-                location: Location::new(1, 7),
-                end_location: Location::new(1, 15),
-            },
-            Fix {
-                content: "ignored".to_string(),
-                location: Location::new(1, 9),
-                end_location: Location::new(1, 11),
-            },
-        ];
-        let locator = SourceCodeLocator::new(
-            r#"
-class A(object):
-    ...
-"#
-            .trim(),
-        );
-        let (contents, fixed) = apply_fixes(fixes.iter(), &locator);
-        assert_eq!(
-            contents,
-            r#"
-class A:
-    ...
-"#
-            .trim(),
-        );
-        assert_eq!(fixed, 1);
-    }
-}
--- a/src/autofix/helpers.rs
+++ b/src/autofix/helpers.rs
@@ -9,10 +9,10 @@ use crate::ast::helpers;
 use crate::ast::helpers::to_absolute;
 use crate::ast::types::Range;
 use crate::ast::whitespace::LinesWithTrailingNewline;
-use crate::autofix::Fix;
 use crate::cst::helpers::compose_module_path;
 use crate::cst::matchers::match_module;
-use crate::source_code_locator::SourceCodeLocator;
+use crate::fix::Fix;
+use crate::source_code::Locator;

 /// Determine if a body contains only a single statement, taking into account
 /// deleted.
@@ -78,7 +78,7 @@ fn is_lone_child(child: &Stmt, parent: &Stmt, deleted: &[&Stmt]) -> Result<bool>

 /// Return the location of a trailing semicolon following a `Stmt`, if it's part
 /// of a multi-statement line.
-fn trailing_semicolon(stmt: &Stmt, locator: &SourceCodeLocator) -> Option<Location> {
+fn trailing_semicolon(stmt: &Stmt, locator: &Locator) -> Option<Location> {
    let contents = locator.slice_source_code_at(&stmt.end_location.unwrap());
    for (row, line) in LinesWithTrailingNewline::from(&contents).enumerate() {
        let trimmed = line.trim();
@@ -100,7 +100,7 @@ fn trailing_semicolon(stmt: &Stmt, locator: &SourceCodeLocator) -> Option<Locati
 }

 /// Find the next valid break for a `Stmt` after a semicolon.
-fn next_stmt_break(semicolon: Location, locator: &SourceCodeLocator) -> Location {
+fn next_stmt_break(semicolon: Location, locator: &Locator) -> Location {
    let start_location = Location::new(semicolon.row(), semicolon.column() + 1);
    let contents = locator.slice_source_code_at(&start_location);
    for (row, line) in LinesWithTrailingNewline::from(&contents).enumerate() {
@@ -133,7 +133,7 @@ fn next_stmt_break(semicolon: Location, locator: &SourceCodeLocator) -> Location
 }

 /// Return `true` if a `Stmt` occurs at the end of a file.
-fn is_end_of_file(stmt: &Stmt, locator: &SourceCodeLocator) -> bool {
+fn is_end_of_file(stmt: &Stmt, locator: &Locator) -> bool {
    let contents = locator.slice_source_code_at(&stmt.end_location.unwrap());
    contents.is_empty()
 }
@@ -155,7 +155,7 @@ pub fn delete_stmt(
    stmt: &Stmt,
    parent: Option<&Stmt>,
    deleted: &[&Stmt],
-    locator: &SourceCodeLocator,
+    locator: &Locator,
 ) -> Result<Fix> {
    if parent
        .map(|parent| is_lone_child(stmt, parent, deleted))
@@ -197,7 +197,7 @@ pub fn remove_unused_imports<'a>(
    stmt: &Stmt,
    parent: Option<&Stmt>,
    deleted: &[&Stmt],
-    locator: &SourceCodeLocator,
+    locator: &Locator,
 ) -> Result<Fix> {
    let module_text = locator.slice_source_code_range(&Range::from_located(stmt));
    let mut tree = match_module(&module_text)?;
@@ -210,14 +210,17 @@ pub fn remove_unused_imports<'a>(
        Some(SmallStatement::Import(import_body)) => (&mut import_body.names, None),
        Some(SmallStatement::ImportFrom(import_body)) => {
            if let ImportNames::Aliases(names) = &mut import_body.names {
-                (names, import_body.module.as_ref())
+                (
+                    names,
+                    Some((&import_body.relative, import_body.module.as_ref())),
+                )
            } else if let ImportNames::Star(..) = &import_body.names {
                // Special-case: if the import is a `from ... import *`, then we delete the
                // entire statement.
                let mut found_star = false;
                for unused_import in unused_imports {
                    let full_name = match import_body.module.as_ref() {
-                        Some(module_name) => format!("{}.*", compose_module_path(module_name),),
+                        Some(module_name) => format!("{}.*", compose_module_path(module_name)),
                        None => "*".to_string(),
                    };
                    if unused_import == full_name {
@@ -246,11 +249,25 @@ pub fn remove_unused_imports<'a>(
    for unused_import in unused_imports {
        let alias_index = aliases.iter().position(|alias| {
            let full_name = match import_module {
-                Some(module_name) => format!(
-                    "{}.{}",
-                    compose_module_path(module_name),
-                    compose_module_path(&alias.name)
-                ),
+                Some((relative, module)) => {
+                    let module = module.map(compose_module_path);
+                    let member = compose_module_path(&alias.name);
+                    let mut full_name = String::with_capacity(
+                        relative.len()
+                            + module.as_ref().map_or(0, std::string::String::len)
+                            + member.len()
+                            + 1,
+                    );
+                    for _ in 0..relative.len() {
+                        full_name.push('.');
+                    }
+                    if let Some(module) = module {
+                        full_name.push_str(&module);
+                        full_name.push('.');
+                    }
+                    full_name.push_str(&member);
+                    full_name
+                }
                None => compose_module_path(&alias.name),
            };
            full_name == unused_import
@@ -299,20 +316,20 @@ mod tests {
    use rustpython_parser::parser;

    use crate::autofix::helpers::{next_stmt_break, trailing_semicolon};
-    use crate::source_code_locator::SourceCodeLocator;
+    use crate::source_code::Locator;

    #[test]
    fn find_semicolon() -> Result<()> {
        let contents = "x = 1";
        let program = parser::parse_program(contents, "<filename>")?;
        let stmt = program.first().unwrap();
-        let locator = SourceCodeLocator::new(contents);
+        let locator = Locator::new(contents);
        assert_eq!(trailing_semicolon(stmt, &locator), None);

        let contents = "x = 1; y = 1";
        let program = parser::parse_program(contents, "<filename>")?;
        let stmt = program.first().unwrap();
-        let locator = SourceCodeLocator::new(contents);
+        let locator = Locator::new(contents);
        assert_eq!(
            trailing_semicolon(stmt, &locator),
            Some(Location::new(1, 5))
@@ -321,7 +338,7 @@ mod tests {
        let contents = "x = 1 ; y = 1";
        let program = parser::parse_program(contents, "<filename>")?;
        let stmt = program.first().unwrap();
-        let locator = SourceCodeLocator::new(contents);
+        let locator = Locator::new(contents);
        assert_eq!(
            trailing_semicolon(stmt, &locator),
            Some(Location::new(1, 6))
@@ -334,7 +351,7 @@ x = 1 \
        .trim();
        let program = parser::parse_program(contents, "<filename>")?;
        let stmt = program.first().unwrap();
-        let locator = SourceCodeLocator::new(contents);
+        let locator = Locator::new(contents);
        assert_eq!(
            trailing_semicolon(stmt, &locator),
            Some(Location::new(2, 2))
@@ -346,14 +363,14 @@ x = 1 \
    #[test]
    fn find_next_stmt_break() {
        let contents = "x = 1; y = 1";
-        let locator = SourceCodeLocator::new(contents);
+        let locator = Locator::new(contents);
        assert_eq!(
            next_stmt_break(Location::new(1, 4), &locator),
            Location::new(1, 5)
        );

        let contents = "x = 1 ; y = 1";
-        let locator = SourceCodeLocator::new(contents);
+        let locator = Locator::new(contents);
        assert_eq!(
            next_stmt_break(Location::new(1, 5), &locator),
            Location::new(1, 6)
@@ -364,7 +381,7 @@ x = 1 \
  ; y = 1
 "#
        .trim();
-        let locator = SourceCodeLocator::new(contents);
+        let locator = Locator::new(contents);
        assert_eq!(
            next_stmt_break(Location::new(2, 2), &locator),
            Location::new(2, 4)
--- a/src/autofix/mod.rs
+++ b/src/autofix/mod.rs
@@ -1,38 +1,210 @@
+use std::borrow::Cow;
+use std::collections::BTreeSet;
+
+use itertools::Itertools;
+use ropey::RopeBuilder;
 use rustpython_ast::Location;
-use serde::{Deserialize, Serialize};
+
+use crate::ast::types::Range;
+use crate::fix::Fix;
+use crate::registry::Diagnostic;
+use crate::source_code::Locator;

 pub mod fixer;
 pub mod helpers;

-#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
-pub struct Fix {
-    pub content: String,
-    pub location: Location,
-    pub end_location: Location,
+/// Auto-fix errors in a file, and write the fixed source code to disk.
+pub fn fix_file<'a>(
+    diagnostics: &'a [Diagnostic],
+    locator: &'a Locator<'a>,
+) -> Option<(Cow<'a, str>, usize)> {
+    if diagnostics.iter().all(|check| check.fix.is_none()) {
+        return None;
+    }
+
+    Some(apply_fixes(
+        diagnostics.iter().filter_map(|check| check.fix.as_ref()),
+        locator,
+    ))
 }

-impl Fix {
-    pub fn deletion(start: Location, end: Location) -> Self {
-        Self {
+/// Apply a series of fixes.
+fn apply_fixes<'a>(
+    fixes: impl Iterator<Item = &'a Fix>,
+    locator: &'a Locator<'a>,
+) -> (Cow<'a, str>, usize) {
+    let mut output = RopeBuilder::new();
+    let mut last_pos: Location = Location::new(1, 0);
+    let mut applied: BTreeSet<&Fix> = BTreeSet::default();
+    let mut num_fixed: usize = 0;
+
+    for fix in fixes.sorted_by_key(|fix| fix.location) {
+        // If we already applied an identical fix as part of another correction, skip
+        // any re-application.
+        if applied.contains(&fix) {
+            num_fixed += 1;
+            continue;
+        }
+
+        // Best-effort approach: if this fix overlaps with a fix we've already applied,
+        // skip it.
+        if last_pos > fix.location {
+            continue;
+        }
+
+        // Add all contents from `last_pos` to `fix.location`.
+        let slice = locator.slice_source_code_range(&Range::new(last_pos, fix.location));
+        output.append(&slice);
+
+        // Add the patch itself.
+        output.append(&fix.content);
+
+        // Track that the fix was applied.
+        last_pos = fix.end_location;
+        applied.insert(fix);
+        num_fixed += 1;
+    }
+
+    // Add the remaining content.
+    let slice = locator.slice_source_code_at(&last_pos);
+    output.append(&slice);
+
+    (Cow::from(output.finish()), num_fixed)
+}
+
+#[cfg(test)]
+mod tests {
+    use rustpython_parser::ast::Location;
+
+    use crate::autofix::apply_fixes;
+    use crate::fix::Fix;
+    use crate::source_code::Locator;
+
+    #[test]
+    fn empty_file() {
+        let fixes = vec![];
+        let locator = Locator::new(r#""#);
+        let (contents, fixed) = apply_fixes(fixes.iter(), &locator);
+        assert_eq!(contents, "");
+        assert_eq!(fixed, 0);
+    }
+
+    #[test]
+    fn apply_single_replacement() {
+        let fixes = vec![Fix {
+            content: "Bar".to_string(),
+            location: Location::new(1, 8),
+            end_location: Location::new(1, 14),
+        }];
+        let locator = Locator::new(
+            r#"
+class A(object):
+    ...
+"#
+            .trim(),
+        );
+        let (contents, fixed) = apply_fixes(fixes.iter(), &locator);
+        assert_eq!(
+            contents,
+            r#"
+class A(Bar):
+    ...
+"#
+            .trim(),
+        );
+        assert_eq!(fixed, 1);
+    }
+
+    #[test]
+    fn apply_single_removal() {
+        let fixes = vec![Fix {
            content: String::new(),
-            location: start,
-            end_location: end,
-        }
+            location: Location::new(1, 7),
+            end_location: Location::new(1, 15),
+        }];
+        let locator = Locator::new(
+            r#"
+class A(object):
+    ...
+"#
+            .trim(),
+        );
+        let (contents, fixed) = apply_fixes(fixes.iter(), &locator);
+        assert_eq!(
+            contents,
+            r#"
+class A:
+    ...
+"#
+            .trim()
+        );
+        assert_eq!(fixed, 1);
    }

-    pub fn replacement(content: String, start: Location, end: Location) -> Self {
-        Self {
-            content,
-            location: start,
-            end_location: end,
-        }
+    #[test]
+    fn apply_double_removal() {
+        let fixes = vec![
+            Fix {
+                content: String::new(),
+                location: Location::new(1, 7),
+                end_location: Location::new(1, 16),
+            },
+            Fix {
+                content: String::new(),
+                location: Location::new(1, 16),
+                end_location: Location::new(1, 23),
+            },
+        ];
+        let locator = Locator::new(
+            r#"
+class A(object, object):
+    ...
+"#
+            .trim(),
+        );
+        let (contents, fixed) = apply_fixes(fixes.iter(), &locator);
+
+        assert_eq!(
+            contents,
+            r#"
+class A:
+    ...
+"#
+            .trim()
+        );
+        assert_eq!(fixed, 2);
    }

-    pub fn insertion(content: String, at: Location) -> Self {
-        Self {
-            content,
-            location: at,
-            end_location: at,
-        }
+    #[test]
+    fn ignore_overlapping_fixes() {
+        let fixes = vec![
+            Fix {
+                content: String::new(),
+                location: Location::new(1, 7),
+                end_location: Location::new(1, 15),
+            },
+            Fix {
+                content: "ignored".to_string(),
+                location: Location::new(1, 9),
+                end_location: Location::new(1, 11),
+            },
+        ];
+        let locator = Locator::new(
+            r#"
+class A(object):
+    ...
+"#
+            .trim(),
+        );
+        let (contents, fixed) = apply_fixes(fixes.iter(), &locator);
+        assert_eq!(
+            contents,
+            r#"
+class A:
+    ...
+"#
+            .trim(),
+        );
+        assert_eq!(fixed, 1);
    }
 }
--- a/src/cache.rs
+++ b/src/cache.rs
@@ -1,132 +1,9 @@
-use std::collections::hash_map::DefaultHasher;
-use std::fs;
-use std::hash::{Hash, Hasher};
-use std::io::Write;
 use std::path::{Path, PathBuf};

-use anyhow::Result;
-use filetime::FileTime;
-use log::error;
-use path_absolutize::Absolutize;
-use serde::{Deserialize, Serialize};
-
-use crate::message::Message;
-use crate::settings::{flags, Settings};
-
 pub const CACHE_DIR_NAME: &str = ".ruff_cache";

-const CARGO_PKG_VERSION: &str = env!("CARGO_PKG_VERSION");
-
-#[derive(Serialize, Deserialize)]
-struct CacheMetadata {
-    mtime: i64,
-}
-
-#[derive(Serialize)]
-struct CheckResultRef<'a> {
-    metadata: &'a CacheMetadata,
-    messages: &'a [Message],
-}
-
-#[derive(Deserialize)]
-struct CheckResult {
-    metadata: CacheMetadata,
-    messages: Vec<Message>,
-}
-
 /// Return the cache directory for a given project root. Defers to the
 /// `RUFF_CACHE_DIR` environment variable, if set.
 pub fn cache_dir(project_root: &Path) -> PathBuf {
    project_root.join(CACHE_DIR_NAME)
 }
-
-fn content_dir() -> &'static Path {
-    Path::new("content")
-}
-
-fn cache_key<P: AsRef<Path>>(path: P, settings: &Settings, autofix: flags::Autofix) -> u64 {
-    let mut hasher = DefaultHasher::new();
-    CARGO_PKG_VERSION.hash(&mut hasher);
-    path.as_ref().absolutize().unwrap().hash(&mut hasher);
-    settings.hash(&mut hasher);
-    autofix.hash(&mut hasher);
-    hasher.finish()
-}
-
-/// Initialize the cache at the specified `Path`.
-pub fn init(path: &Path) -> Result<()> {
-    // Create the cache directories.
-    fs::create_dir_all(path.join(content_dir()))?;
-
-    // Add the CACHEDIR.TAG.
-    if !cachedir::is_tagged(path)? {
-        cachedir::add_tag(path)?;
-    }
-
-    // Add the .gitignore.
-    let gitignore_path = path.join(".gitignore");
-    if !gitignore_path.exists() {
-        let mut file = fs::File::create(gitignore_path)?;
-        file.write_all(b"*")?;
-    }
-
-    Ok(())
-}
-
-fn write_sync(cache_dir: &Path, key: u64, value: &[u8]) -> Result<(), std::io::Error> {
-    fs::write(
-        cache_dir.join(content_dir()).join(format!("{key:x}")),
-        value,
-    )
-}
-
-fn read_sync(cache_dir: &Path, key: u64) -> Result<Vec<u8>, std::io::Error> {
-    fs::read(cache_dir.join(content_dir()).join(format!("{key:x}")))
-}
-
-/// Get a value from the cache.
-pub fn get<P: AsRef<Path>>(
-    path: P,
-    metadata: &fs::Metadata,
-    settings: &Settings,
-    autofix: flags::Autofix,
-) -> Option<Vec<Message>> {
-    let encoded = read_sync(&settings.cache_dir, cache_key(path, settings, autofix)).ok()?;
-    let (mtime, messages) = match bincode::deserialize::<CheckResult>(&encoded[..]) {
-        Ok(CheckResult {
-            metadata: CacheMetadata { mtime },
-            messages,
-        }) => (mtime, messages),
-        Err(e) => {
-            error!("Failed to deserialize encoded cache entry: {e:?}");
-            return None;
-        }
-    };
-    if FileTime::from_last_modification_time(metadata).unix_seconds() != mtime {
-        return None;
-    }
-    Some(messages)
-}
-
-/// Set a value in the cache.
-pub fn set<P: AsRef<Path>>(
-    path: P,
-    metadata: &fs::Metadata,
-    settings: &Settings,
-    autofix: flags::Autofix,
-    messages: &[Message],
-) {
-    let check_result = CheckResultRef {
-        metadata: &CacheMetadata {
-            mtime: FileTime::from_last_modification_time(metadata).unix_seconds(),
-        },
-        messages,
-    };
-    if let Err(e) = write_sync(
-        &settings.cache_dir,
-        cache_key(path, settings, autofix),
-        &bincode::serialize(&check_result).unwrap(),
-    ) {
-        error!("Failed to write to cache: {e:?}");
-    }
-}
--- a/src/checkers/ast.rs
+++ b/src/checkers/ast.rs
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Charlie Marsh	931d41bff1	Revert "Bump version to 0.0.222" This reverts commit `852aab5758`.	2023-01-13 23:56:29 -05:00
Charlie Marsh	852aab5758	Bump version to 0.0.222	2023-01-13 23:50:08 -05:00
Charlie Marsh	27fe4873f2	Fix placement of update feature flag	2023-01-13 23:46:32 -05:00
Charlie Marsh	ee6c81d02a	Bump version to 0.0.221	2023-01-13 23:33:15 -05:00
Charlie Marsh	59542344e2	Avoid unnecessary allocations for module names (#1863 )	2023-01-13 23:26:34 -05:00
Martin Fischer	7b1ce72f86	Actually fix wasm-pack build command (#1862 ) I initially attempted to run `wasm-pack build -p ruff` which gave the error message: Error: crate directory is missing a `Cargo.toml` file; is `-p` the wrong directory? I interpreted that as wasm-pack looking for the "ruff" directory because I specified -p ruff, however actually the wasm-pack build usage is: wasm-pack build [FLAGS] [OPTIONS] <path> <cargo-build-options> And I was missing the `<path>` argument. So this actually wasn't at all a bug in wasm-pack but just a confusing error message. And the symlink hack I introduced in the previous commit didn't actually work ... I only accidentally omitted the `-p` when testing (which ended up as `ruff` being the <path> argument) ... CLIs are fun.	2023-01-13 23:20:20 -05:00
Martin Fischer	156e09536e	Add workaround for wasm-pack bug to fix the playground CI (#1861 ) Fixes #1860.	2023-01-13 22:46:51 -05:00
Charlie Marsh	22341c4ae4	Move repology down	2023-01-13 22:29:26 -05:00
Colin Delahunty	e4993bd7e2	Added ALE (#1857 ) Fixes the sub issue I brought up in #1829.	2023-01-13 21:39:51 -05:00
Martin Fischer	82aff5f9ec	Split off ruff_cli crate from ruff library This lets you test the ruff linters or use the ruff library without having to compile the ~100 additional dependencies that are needed by the CLI. Because we set the following in the [workspace] section of Cargo.toml: default-members = [".", "ruff_cli"] `cargo run` still runs the CLI and `cargo test` still tests the code in src/ as well as the code in the new ruff_cli crate. (But you can now also run `cargo test -p ruff` to only test the linters.)	2023-01-13 21:37:54 -05:00
Charlie Marsh	403a004e03	Refactor import-tracking to leverage existing AST bindings (#1856 ) This PR refactors our import-tracking logic to leverage our existing logic for tracking bindings. It's both a significant simplification, a significant improvement (as we can now track reassignments), and closes out a bunch of subtle bugs. Though the AST tracks all bindings (e.g., when parsing `import os as foo`, we bind the name `foo` to a `BindingKind::Importation` that points to the `os` module), when I went to implement import tracking (e.g., to ensure that if the user references `List`, it's actually `typing.List`), I added a parallel system specifically for this use-case. That was a mistake, for a few reasons: 1. It didn't track reassignments, so if you had `from typing import List`, but `List` was later overridden, we'd still consider any reference to `List` to be `typing.List`. 2. It required a bunch of extra logic, include complex logic to try and optimize the lookups, since it's such a hot codepath. 3. There were a few bugs in the implementation that were just hard to correct under the existing abstractions (e.g., if you did `from typing import Optional as Foo`, then we'd treat any reference to `Foo` _or_ `Optional` as `typing.Optional` (even though, in that case, `Optional` was really unbound). The new implementation goes through our existing binding tracking: when we get a reference, we find the appropriate binding given the current scope stack, and normalize it back to its original target. Closes #1690. Closes #1790.	2023-01-13 20:39:54 -05:00
Charlie Marsh	0b92849996	Improve spacing preservation for `C405` fixes (#1855 ) We now preserve the spacing of the more common form: ```py set(( 1, )) ``` Rather than the less common form: ```py set( (1,) ) ```	2023-01-13 13:11:08 -05:00
Charlie Marsh	12440ede9c	Remove non-magic trailing comma from tuple (#1854 ) Closes #1821.	2023-01-13 12:56:42 -05:00
max0x53	fc3f722df5	Implement `PLR0133` (`ComparisonOfConstants`) (#1841 ) This PR adds [Pylint `R0133`](https://pylint.pycqa.org/en/latest/user_guide/messages/refactor/comparison-of-constants.html) Feel free to suggest changes and additions, I have tried to maintain parity with the Pylint implementation [`comparison_checker.py`](https://github.com/PyCQA/pylint/blob/main/pylint/checkers/base/comparison_checker.py#L247) See #970	2023-01-13 12:14:35 -05:00
Maksudul Haque	84ef7a0171	[`isort`] Add `classes` Config Option (#1849 ) ref https://github.com/charliermarsh/ruff/issues/1819	2023-01-13 12:13:01 -05:00
Nicola Soranzo	66b1d09362	Clarify that some flake8-bugbear opinionated rules are already implemented (#1847 ) E.g. B904 and B905.	2023-01-13 11:49:05 -05:00
Maksudul Haque	3ae01db226	[`flake8-bugbear`] Fix False Positives for `B024` & `B027` (#1851 ) closes https://github.com/charliermarsh/ruff/issues/1848	2023-01-13 11:46:17 -05:00
Charlie Marsh	048e5774e8	Use absolute paths for --stdin-filename matching (#1843 ) Non-basename glob matches (e.g., for `--per-file-ignores`) assume that the path has been converted to an absolute path. (We do this for filenames as part of the directory traversal.) For filenames passed via stdin, though, we're missing this conversion. So `--per-file-ignores` that rely on the _basename_ worked as expected, but directory paths did not. Closes #1840.	2023-01-12 21:01:05 -05:00
max0x53	b47e8e6770	Implement `PLR2004` (`MagicValueComparison`) (#1828 ) This PR adds [Pylint `R2004`](https://pylint.pycqa.org/en/latest/user_guide/messages/refactor/magic-value-comparison.html#magic-value-comparison-r2004) Feel free to suggest changes and additions, I have tried to maintain parity with the Pylint implementation [`magic_value.py`](https://github.com/PyCQA/pylint/blob/main/pylint/extensions/magic_value.py) See #970	2023-01-12 19:44:18 -05:00
Jan Katins	ef17c82998	Document the way extend-ignore/select are applied (#1839 ) Closes: https://github.com/charliermarsh/ruff/issues/1838	2023-01-12 19:44:03 -05:00
Charlie Marsh	9aeb5df5fe	Bump version to 0.0.220	2023-01-12 17:57:04 -05:00
Charlie Marsh	7ffba7b552	Use absolute paths for GitHub and Gitlab annotations (#1837 ) Note that the _annotation path_ is absolute, while the path encoded in the message remains relative. ![Screen Shot 2023-01-12 at 5 54 11 PM](https://user-images.githubusercontent.com/1309177/212198531-63f15445-0f6a-471c-a64c-18ad2b6df0c7.png) Closes #1835.	2023-01-12 17:54:34 -05:00
Charlie Marsh	06473bb1b5	Support for-else loops in `SIM110` and `SIM111` (#1834 ) This PR adds support for `SIM110` and `SIM111` simplifications of the form: ```py def f(): # SIM110 for x in iterable: if check(x): return True else: return False ```	2023-01-12 17:04:58 -05:00
Ash Berlin-Taylor	bf5c048502	Airflow is now using ruff (#1833 ) 😀	2023-01-12 16:50:01 -05:00
Charlie Marsh	eaed08ae79	Skip SIM110/SIM111 fixes that create long lines	2023-01-12 16:21:54 -05:00
Charlie Marsh	e0fdc4c5e8	Avoid SIM110/SIM110 errors with else statements (#1832 ) Closes #1831.	2023-01-12 16:17:27 -05:00
Charlie Marsh	590bec57f4	Fix typo in relative-imports-order option name	2023-01-12 15:57:58 -05:00
Charlie Marsh	3110d342c7	Implement isort's `reverse_relative` setting (#1826 ) This PR implements `reverse-relative`, from isort, but renames it to `relative-imports-order` with the respected value `closest-to-furthest` and `furthest-to-closest`, and the latter being the default. Closes #1813.	2023-01-12 15:48:40 -05:00
nefrob	39aae28eb4	📝 Update readme example for adding isort required imports (#1824 ) Fixes use of isort name to the ruff name.	2023-01-12 13:18:06 -05:00
Charlie Marsh	dcccfe2591	Avoid parsing pyproject.toml files when settings are fixed (#1827 ) Apart from being wasteful, this can also cause problems (see the linked issue). Resolves #1812.	2023-01-12 13:15:44 -05:00
Martin Fischer	38f5e8f423	Decouple linter module from cache module	2023-01-12 13:09:59 -05:00
Martin Fischer	74f14182ea	Decouple resolver module from cli::Overrides	2023-01-12 13:09:59 -05:00
Charlie Marsh	bbc1e7804e	Don't trigger SIM401 for complex default values (#1825 ) Resolves #1809.	2023-01-12 12:51:23 -05:00
messense	c6320b29e4	Implement autofix for flake8-quotes (#1810 ) Resolves #1789	2023-01-12 12:42:28 -05:00
Maksudul Haque	1a90408e8c	[`flake8-bandit`] Add Rule for `S701` (jinja2 autoescape false) (#1815 ) ref: https://github.com/charliermarsh/ruff/issues/1646 Co-authored-by: Charlie Marsh <charlie.r.marsh@gmail.com>	2023-01-12 11:59:20 -05:00
Jeroen Van Goey	07134c50c8	Add usage of ruff in pandas to README (#1811 ) pandas now uses ruff for linting, see https://github.com/pandas-dev/pandas/pull/50160	2023-01-12 10:55:21 -05:00
Charlie Marsh	b36d4a15b0	Modify visibility and shuffle around some modules (#1807 )	2023-01-11 23:57:05 -05:00
Charlie Marsh	d8162ce79d	Bump version to 0.0.219	2023-01-11 23:46:01 -05:00
Charlie Marsh	e11ef54bda	Improve globset documentation and help message (#1808 ) Closes #1545.	2023-01-11 23:41:56 -05:00
messense	9a07b0623e	Move top level `ruff` into `python` folder (#1806 ) https://maturin.rs/project_layout.html#mixed-rustpython-project Resolves #1805	2023-01-11 23:12:55 -05:00
Charlie Marsh	f450e2e79d	Implement doc line length enforcement (#1804 ) This PR implements `W505` (`DocLineTooLong`), which is similar to `E501` (`LineTooLong`) but confined to doc lines. I based the "doc line" definition on pycodestyle, which defines a doc line as a standalone comment or string statement. Our definition is a bit more liberal, since we consider any string statement a doc line (even if it's part of a multi-line statement) -- but that seems fine to me. Note that, unusually, this rule requires custom extraction from both the token stream (to find standalone comments) and the AST (to find string statements). Closes #1784.	2023-01-11 22:32:14 -05:00
Colin Delahunty	329946f162	Avoid erroneous Q002 error message for single-quote docstrings (#1777 ) Fixes #1775. Before implementing your solution I thought of a slightly simpler one. However, it will let this function pass: ``` def double_inside_single(a): 'Double inside "single "' ``` If we want function to pass, my implementation works. But if we do not, then I can go with how you suggested I implemented this (I left how I would begin to handle it commented out). The bottom of the flake8-quotes documentation seems to suggest that this should pass: https://pypi.org/project/flake8-quotes/ Co-authored-by: Charlie Marsh <charlie.r.marsh@gmail.com>	2023-01-11 20:01:54 -05:00
Charlie Marsh	588399e415	Fix Clippy error	2023-01-11 19:59:00 -05:00
Chammika Mannakkara	4523885268	flake8_simplify : SIM401 (#1778 ) Ref #998 - Implements SIM401 with fix - Added tests Notes: - only recognize simple ExprKind::Name variables in expr patterns for now - bug-fix from reference implementation: check 3-conditions (dict-key, target-variable, dict-name) to be equal, `flake8_simplify` only test first two (only first in second pattern)	2023-01-11 19:51:37 -05:00
Maksudul Haque	de81b0cd38	[`flake8-simplify`] Add Rule for `SIM115` (Use context handler for opening files) (#1782 ) ref: https://github.com/charliermarsh/ruff/issues/998 Co-authored-by: Charlie Marsh <charlie.r.marsh@gmail.com>	2023-01-11 19:28:05 -05:00
Charlie Marsh	4fce296e3f	Skip SIM108 violations for complex if-statements (#1802 ) We now skip SIM108 violations if: the resulting statement would exceed the user-specified line length, or the `if` statement contains comments. Closes #1719. Closes #1766.	2023-01-11 19:21:30 -05:00
Charlie Marsh	9d48d7bbd1	Skip unused argument checks for magic methods (#1801 ) We still check `__init__`, `__call__`, and `__new__`. Closes #1796.	2023-01-11 19:02:20 -05:00
Charlie Marsh	c56f263618	Avoid flagging builtins for OSError rewrites (#1800 ) Related to (but does not fix) #1790.	2023-01-11 18:49:25 -05:00
Grzegorz Bokota	fb2382fbc3	Update readme to reflect #1763 (#1780 ) When checking changes in the 0.0.218 release I noticed that auto fixing PT004 and PT005 was disabled but this change was not reflected in README. So I create this small PR to do this. Co-authored-by: Charlie Marsh <charlie.r.marsh@gmail.com>	2023-01-11 18:37:41 -05:00
Charlie Marsh	c92a5a8704	Avoid rewriting flake8-comprehensions expressions for builtin overrides (#1799 ) Closes #1788.	2023-01-11 18:33:55 -05:00
Charlie Marsh	d7cf3147b7	Refactor flake8-comprehensions rules to take fewer arguments (#1797 )	2023-01-11 18:21:18 -05:00
Charlie Marsh	bf4d35c705	Convert flake8-comprehensions checks to Checker style (#1795 )	2023-01-11 18:11:20 -05:00
Charlie Marsh	4e97e9c7cf	Improve PIE794 autofix behavior (#1794 ) We now: (1) trigger PIE794 for objects without bases (not sure why this was omitted before); and (2) remove the entire line, rather than leaving behind trailing whitespace. Resolves #1787.	2023-01-11 18:01:29 -05:00
Charlie Marsh	a3fcc3b28d	Disable update check by default (#1786 ) This has received enough criticism that I'm comfortable making it opt-in.	2023-01-11 13:47:40 -05:00
Charlie Marsh	cfbd068dd5	Bump version to 0.0.218	2023-01-10 21:28:23 -05:00
Charlie Marsh	8aed23fe0a	Avoid B023 false-positives for some common builtins (#1776 ) This is based on the upstream work in https://github.com/PyCQA/flake8-bugbear/pull/303 and https://github.com/PyCQA/flake8-bugbear/pull/305/files. Resolves #1686.	2023-01-10 21:23:48 -05:00
Colin Delahunty	c016c41c71	Pyupgrade: Format specifiers (#1594 ) A part of #827. Posting this for visibility. Still has some work to do to be done. Things that still need done before this is ready: - [x] Does not work when the item is being assigned to a variable - [x] Does not work if being used in a function call - [x] Fix incorrectly removed calls in the function - [x] Has not been tested with pyupgrade negative test cases Tests from pyupgrade can be seen here: https://github.com/asottile/pyupgrade/blob/main/tests/features/format_literals_test.py Co-authored-by: Charlie Marsh <charlie.r.marsh@gmail.com>	2023-01-10 20:21:04 -05:00
Charlie Marsh	f1a5e53f06	Enable isort-style `required-imports` enforcement (#1762 ) In isort, this is called `add-imports`, but I prefer the declarative name. The idea is that by adding the following to your `pyproject.toml`, you can ensure that the import is included in all files: ```toml [tool.ruff.isort] required-imports = ["from __future__ import annotations"] ``` I mostly reverse-engineered isort's logic for making decisions, though I made some slight tweaks that I think are preferable. A few comments: - Like isort, we don't enforce this on empty files (like empty `__init__.py`). - Like isort, we require that the import is at the top-level. - isort will skip any docstrings, and any comments on the first three lines (I think, based on testing). Ruff places the import after the last docstring or comment in the file preamble (that is: after the last docstring or comment that comes before the _first_ non-docstring and non-comment). Resolves #1700.	2023-01-10 18:12:57 -05:00
Charlie Marsh	1e94e0221f	Disable doctests (#1772 ) We don't have any doctests, but `cargo test --all` spends more than half the time on doctests? A little confusing, but this brings the test time from > 4s to < 2s on my machine.	2023-01-10 15:10:16 -05:00
Martin Fischer	543865c96b	Generate RuleCode::origin() via macro (#1770 )	2023-01-10 13:20:43 -05:00
Maksudul Haque	b8e3f0bc13	[`flake8-bandit`] Add Rule for `S508` (snmp insecure version) & `S509` (snmp weak cryptography) (#1771 ) ref: https://github.com/charliermarsh/ruff/issues/1646 Co-authored-by: messense <messense@icloud.com> Co-authored-by: Charlie Marsh <charlie.r.marsh@gmail.com>	2023-01-10 13:13:54 -05:00
Charlie Marsh	643cedb200	Move CONTRIBUTING.md to top-level (#1768 )	2023-01-10 07:38:12 -05:00
Charlie Marsh	91620c378a	Disable release builds on CI (#1761 )	2023-01-10 07:33:03 -05:00
Harutaka Kawamura	b732135795	Do not autofix PT004 and PT005 (#1763 ) As @edgarrmondragon commented in https://github.com/charliermarsh/ruff/pull/1740#issuecomment-1376230550, just renaming fixture doesn't work.	2023-01-10 07:24:16 -05:00
messense	9384a081f9	Implement flake8-simplify SIM112 (#1764 ) Ref #998	2023-01-10 07:24:01 -05:00
Charlie Marsh	edab268d50	Bump version to 0.0.217	2023-01-09 23:26:22 -05:00
Charlie Marsh	e4fad70a57	Update documentation to match latest terminology (#1760 ) Closes #1759.	2023-01-09 21:10:47 -05:00
Charlie Marsh	1a09fff991	Update rule-generation `scripts` to match latest conventions (#1758 ) Resolves #1755.	2023-01-09 19:55:46 -05:00
Charlie Marsh	b85105d2ec	Add a helper for any-like operations (#1757 )	2023-01-09 19:34:33 -05:00
Charlie Marsh	f7ac28a935	Omit `sys.version_info` and `sys.platform` checks from ternary rule (#1756 ) Resolves #1753.	2023-01-09 19:22:34 -05:00
Charlie Marsh	9532f342a6	Enable project-specific typing module re-exports (#1754 ) Resolves #1744.	2023-01-09 18:17:50 -05:00
Mohamed Daahir	0ee37aa0aa	Cache build artifacts using Swatinem/rust-cache@v1 (#1750 ) This GitHub Action caches build artifacts in addition to dependencies which halves the CI duration time. Resolves #1752.	2023-01-09 15:35:32 -05:00
Charlie Marsh	8a26c8b4e0	Fix wasm builds	2023-01-09 12:58:07 -05:00
Charlie Marsh	2cb59b0f45	Use dedicated warnings for flake8-to-ruff (#1748 )	2023-01-09 12:48:06 -05:00
Charlie Marsh	2729f3d207	Add support for defining extra builtins (#1747 ) Resolves #1745.	2023-01-09 12:24:28 -05:00
Charlie Marsh	59155ce9f6	Rename `checks` and `plugins` to `rules` (#1739 )	2023-01-09 01:39:51 -05:00
Charlie Marsh	caf6c65de7	Bump version to 0.0.216	2023-01-09 01:14:28 -05:00
Matt Oberle	147d594b38	Add isort.force-sort-within-sections setting (#1635 ) This commit is a first attempt at addressing issue #1003. The default `isort` behavior is `force-sort-within-sections = false`, which places `from X import Y` statements after `import X` statements. When `force-sort-within-sections = true` all imports are sorted by module name. When module names are equivalent, the `import` statement comes before the `from` statement.	2023-01-09 01:06:48 -05:00
Charlie Marsh	f18078a1eb	Allow unused arguments for empty methods with docstrings (#1742 ) Resolves #1741.	2023-01-09 00:34:07 -05:00
Harutaka Kawamura	fe4eb13601	Autofix PT004, PT005, PT024, and PT025 (#1740 )	2023-01-08 22:41:00 -05:00
Charlie Marsh	161ab05533	Rename more local usages of `check` to `diagnostic` (#1738 )	2023-01-08 18:10:08 -05:00
Charlie Marsh	2c537e24cc	Move violation structs out of `registry.rs` (#1728 )	2023-01-08 17:54:20 -05:00
Charlie Marsh	0fe349b5f8	Rename `CheckCategory` to `RuleOrigin` (#1726 )	2023-01-08 17:50:18 -05:00
Charlie Marsh	09dc3c7225	Rename `Check` to `Diagnostic` (#1725 ) Along with: - `CheckKind` -> `DiagnosticKind` - `CheckCode` -> `RuleCode` - `CheckCodePrefix` -> `RuleCodePrefix`	2023-01-08 17:46:20 -05:00
Harutaka Kawamura	498134b7ee	Audit unittest assert methods (#1736 ) I ran the following code in Python 3.10 to automatically generate a list of enums. ```python import unittest print( ",\n".join( sorted( m.removeprefix("assert") if m != "assert_" else "Underscore" for m in dir(unittest.TestCase) if m.startswith("assert") ) ) ) ```	2023-01-08 16:21:34 -05:00