Revert "Bump version to 0.0.222"

This reverts commit 852aab5758.

.github/workflows/ci.yaml

@@ -60,7 +60,7 @@ jobs:
           target: wasm32-unknown-unknown
       - 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"
@@ -79,7 +79,7 @@ jobs:
         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

.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

.pre-commit-config.yaml

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

Cargo.lock

@@ -735,7 +735,7 @@ checksum = "0ce7134b9999ecaf8bcd65542e436736ef32ddca1b3e06094cb6ec5755203b80"
 
 [[package]]
 name = "flake8-to-ruff"
-version = "0.0.219-dev.0"
+version = "0.0.221-dev.0"
 dependencies = [
  "anyhow",
  "clap 4.0.32",
@@ -1874,27 +1874,19 @@ dependencies = [
 
 [[package]]
 name = "ruff"
-version = "0.0.219"
+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",
@@ -1906,13 +1898,10 @@ dependencies = [
  "log",
  "natord",
  "nohash-hasher",
- "notify",
  "num-bigint",
  "num-traits",
  "once_cell",
  "path-absolutize",
- "quick-junit",
- "rayon",
  "regex",
  "ropey",
  "ruff_macros",
@@ -1924,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.219"
+version = "0.0.221"
 dependencies = [
  "anyhow",
  "clap 4.0.32",
@@ -1950,6 +1971,7 @@ dependencies = [
  "libcst",
  "once_cell",
  "ruff",
+ "ruff_cli",
  "rustpython-ast",
  "rustpython-common",
  "rustpython-parser",
@@ -1962,7 +1984,7 @@ dependencies = [
 
 [[package]]
 name = "ruff_macros"
-version = "0.0.219"
+version = "0.0.221"
 dependencies = [
  "once_cell",
  "proc-macro2",

Cargo.toml

@@ -2,11 +2,13 @@
 members = [
   "flake8_to_ruff",
   "ruff_dev",
+  "ruff_cli",
 ]
+default-members = [".", "ruff_cli"]
 
 [package]
 name = "ruff"
-version = "0.0.219"
+version = "0.0.221"
 authors = ["Charlie Marsh <charlie.r.marsh@gmail.com>"]
 edition = "2021"
 rust-version = "1.65.0"
@@ -22,20 +24,14 @@ 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" }
@@ -44,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.219", 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" }
@@ -60,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
@@ -88,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"

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,6 +159,8 @@ 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:
@@ -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.219'
+  rev: 'v0.0.221'
   hooks:
     - id: ruff
       # Respect `exclude` and `extend-exclude` settings.
@@ -782,6 +784,7 @@ For more, see [flake8-bandit](https://pypi.org/project/flake8-bandit/4.1.1/) on
 | 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)
 
@@ -950,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)
 
@@ -1091,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 |  |
 
@@ -1251,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>
@@ -1415,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.)
@@ -1905,6 +1922,12 @@ extend-exclude = ["tests", "src/bad.py"]
 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<RuleCodePrefix>`
@@ -1924,6 +1947,12 @@ extend-ignore = ["F841"]
 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<RuleCodePrefix>`
@@ -2861,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)
@@ -3020,6 +3067,30 @@ 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.
@@ -3032,7 +3103,7 @@ Add the specified import line to all files.
 
 ```toml
 [tool.ruff.isort]
-add-import = ["from __future__ import annotations"]
+required-imports = ["from __future__ import annotations"]
 ```
 
 ---

flake8_to_ruff/Cargo.lock

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

flake8_to_ruff/Cargo.toml

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

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.219"
+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,7 @@ urls = { repository = "https://github.com/charliermarsh/ruff" }
 
 [tool.maturin]
 bindings = "bin"
+manifest-path = "ruff_cli/Cargo.toml"
 python-source = "python"
 strip = true
 

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

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

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()

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")
         ...

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,]
+)

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'"

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

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

resources/test/fixtures/flake8_simplify/SIM401.py

@@ -79,3 +79,9 @@ if key in a_dict:
 else:
     var2 = value2
     var = "default"
+
+# OK (complex default value)
+if key in a_dict:
+    var = a_dict[key]
+else:
+    var = foo()

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

resources/test/fixtures/isort/relative_imports_order.py

@@ -0,0 +1,3 @@
+from ... import a
+from .. import b
+from . import c

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
 

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")

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")

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

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
+

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:

ruff.schema.json

@@ -67,7 +67,7 @@
       }
     },
     "extend-ignore": {
-      "description": "A list of rule codes or prefixes to ignore, in addition to those specified by `ignore`.",
+      "description": "A list of rule codes or prefixes to ignore, in addition to those specified by `ignore`.\n\nNote 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`.",
       "type": [
         "array",
         "null"
@@ -77,7 +77,7 @@
       }
     },
     "extend-select": {
-      "description": "A list of rule codes or prefixes to enable, in addition to those specified by `select`.",
+      "description": "A list of rule codes or prefixes to enable, in addition to those specified by `select`.\n\nNote 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`.",
       "type": [
         "array",
         "null"
@@ -755,6 +755,16 @@
     "IsortOptions": {
       "type": "object",
       "properties": {
+        "classes": {
+          "description": "An override list of tokens to always recognize as a Class for `order-by-type` regardless of casing.",
+          "type": [
+            "array",
+            "null"
+          ],
+          "items": {
+            "type": "string"
+          }
+        },
         "combine-as-imports": {
           "description": "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) option.",
           "type": [
@@ -820,6 +830,17 @@
             "null"
           ]
         },
+        "relative-imports-order": {
+          "description": "Whether to place \"closer\" imports (fewer `.` characters, most local) before \"further\" imports (more `.` characters, least local), or vice versa.\n\nThe 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`.",
+          "anyOf": [
+            {
+              "$ref": "#/definitions/RelatveImportsOrder"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
         "required-imports": {
           "description": "Add the specified import line to all files.",
           "type": [
@@ -1007,6 +1028,24 @@
         }
       ]
     },
+    "RelatveImportsOrder": {
+      "oneOf": [
+        {
+          "description": "Place \"closer\" imports (fewer `.` characters, most local) before \"further\" imports (more `.` characters, least local).",
+          "type": "string",
+          "enum": [
+            "closest-to-furthest"
+          ]
+        },
+        {
+          "description": "Place \"further\" imports (more `.` characters, least local) imports before \"closer\" imports (fewer `.` characters, most local).",
+          "type": "string",
+          "enum": [
+            "furthest-to-closest"
+          ]
+        }
+      ]
+    },
     "RuleCodePrefix": {
       "type": "string",
       "enum": [
@@ -1404,6 +1443,9 @@
         "PLE1142",
         "PLR",
         "PLR0",
+        "PLR01",
+        "PLR013",
+        "PLR0133",
         "PLR02",
         "PLR020",
         "PLR0206",
@@ -1416,6 +1458,10 @@
         "PLR1701",
         "PLR172",
         "PLR1722",
+        "PLR2",
+        "PLR20",
+        "PLR200",
+        "PLR2004",
         "PLW",
         "PLW0",
         "PLW01",
@@ -1515,6 +1561,9 @@
         "S506",
         "S508",
         "S509",
+        "S7",
+        "S70",
+        "S701",
         "SIM",
         "SIM1",
         "SIM10",

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.

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:?}");
+    }
+}

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::{RuleCode, RuleCodePrefix};
-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 {
@@ -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 {

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::RuleCode;
-use crate::resolver::{FileDiscovery, PyprojectDiscovery};
-use crate::settings::flags;
-use crate::settings::types::SerializationFormat;
-use crate::{cache, fs, packages, resolver, violations, warn_user_once};
 
 /// 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();
@@ -77,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()
@@ -156,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)? {
@@ -169,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();
@@ -288,7 +288,7 @@ struct Explanation<'a> {
 }
 
 /// Explain a `RuleCode` to the user.
-pub fn explain(code: &RuleCode, format: &SerializationFormat) -> Result<()> {
+pub fn explain(code: &RuleCode, format: SerializationFormat) -> Result<()> {
     match format {
         SerializationFormat::Text | SerializationFormat::Grouped => {
             println!(

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 })
+}

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;

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, warn_user_once};
+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
@@ -176,7 +192,7 @@ pub(crate) fn inner_main() -> Result<ExitCode> {
 
     let printer = Printer::new(&format, &log_level, &autofix, &violations);
     if cli.watch {
-        if !matches!(autofix, fixer::Mode::None) {
+        if !matches!(autofix, fix::FixMode::None) {
             warn_user_once!("--fix is not enabled in watch mode.");
         }
         if format != SerializationFormat::Text {
@@ -193,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();
@@ -223,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()),
@@ -243,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,
@@ -263,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)?;
         }
 

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::notify_user;
-use crate::registry::RuleCode;
-use crate::settings::types::SerializationFormat;
+use crate::diagnostics::Diagnostics;
 
 /// Enum to control whether lint violations are shown to the user.
 pub enum Violations {
@@ -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 {
@@ -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,9 +281,9 @@ 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 {
@@ -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()?;

ruff_cli/tests/black_compatibility_test.rs

@@ -9,7 +9,7 @@ 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};
@@ -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();

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")

ruff_dev/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ruff_dev"
-version = "0.0.219"
+version = "0.0.221"
 edition = "2021"
 
 [lib]
@@ -14,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" }

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;
 

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(())

ruff_macros/Cargo.toml

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

scripts/add_plugin.py

@@ -34,7 +34,7 @@ def main(*, plugin: str, url: str) -> None:
     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 rules;\n")
+        fp.write("pub(crate) mod rules;\n")
         fp.write("\n")
         fp.write(
             """#[cfg(test)]

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

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,150 +55,42 @@ 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,
-    )
-}
-
-/// 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;
-    }
-
-    // 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("*")
-            })
+/// 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 {
-        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;
-        }
-
-        // 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;
-            }
-        }
-
-        false
+        call_path.join(".")
     }
 }
 
 /// Return `true` if the `Expr` contains a reference to `${module}.${target}`.
-pub fn contains_call_path(
-    expr: &Expr,
-    module: &str,
-    member: &str,
-    import_aliases: &FxHashMap<&str, &str>,
-    from_imports: &FxHashMap<&str, FxHashSet<&str>>,
-) -> bool {
+pub fn contains_call_path(checker: &Checker, expr: &Expr, target: &[&str]) -> bool {
     any_over_expr(expr, &|expr| {
-        let call_path = collect_call_paths(expr);
-        if !call_path.is_empty() {
-            if match_call_path(
-                &dealias_call_path(call_path, import_aliases),
-                module,
-                member,
-                from_imports,
-            ) {
-                return true;
-            }
-        }
-        false
+        checker
+            .resolve_call_path(expr)
+            .map_or(false, |call_path| call_path == target)
     })
 }
 
@@ -391,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);
                         }
@@ -431,7 +322,7 @@ pub fn collect_arg_names<'a>(arguments: &'a Arguments) -> FxHashSet<&'a str> {
 }
 
 /// Returns `true` if a statement or expression includes at least one comment.
-pub fn has_comments<T>(located: &Located<T>, locator: &SourceCodeLocator) -> bool {
+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(..)))
@@ -460,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]
     }
 }
 
@@ -483,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),
@@ -508,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
@@ -520,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 { .. }
@@ -539,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
@@ -555,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()
@@ -568,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;
@@ -594,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
@@ -619,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()
@@ -656,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, .. }
@@ -690,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
@@ -711,13 +624,13 @@ 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)
 }
 
@@ -783,6 +696,7 @@ impl<'a> SimpleCallArgs<'a> {
     }
 
     /// Get the number of positional and keyword arguments used.
+    #[allow(clippy::len_without_is_empty)]
     pub fn len(&self) -> usize {
         self.args.len() + self.kwargs.len()
     }
@@ -791,183 +705,37 @@ impl<'a> SimpleCallArgs<'a> {
 #[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#"
@@ -977,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(())
@@ -988,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),)
@@ -1002,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),)
@@ -1011,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),)
@@ -1020,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),)
@@ -1034,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),)
@@ -1043,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),)
@@ -1063,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);

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;
             }

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::Diagnostic;
-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>(
-    diagnostics: &'a [Diagnostic],
-    locator: &'a SourceCodeLocator<'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,
-    ))
-}
-
-/// 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);
-    }
-}

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)

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);
     }
 }

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:?}");
-    }
-}

src/checkers/ast.rs

@@ -14,9 +14,7 @@ use rustpython_parser::ast::{
 };
 use rustpython_parser::parser;
 
-use crate::ast::helpers::{
-    binding_range, collect_call_paths, dealias_call_path, extract_handler_names, match_call_path,
-};
+use crate::ast::helpers::{binding_range, collect_call_path, extract_handler_names};
 use crate::ast::operations::extract_all_names;
 use crate::ast::relocate::relocate_expr;
 use crate::ast::types::{
@@ -33,8 +31,7 @@ use crate::python::typing::SubscriptKind;
 use crate::registry::{Diagnostic, RuleCode};
 use crate::settings::types::PythonVersion;
 use crate::settings::{flags, Settings};
-use crate::source_code_locator::SourceCodeLocator;
-use crate::source_code_style::SourceCodeStyleDetector;
+use crate::source_code::{Locator, Stylist};
 use crate::violations::DeferralKeyword;
 use crate::visibility::{module_visibility, transition_scope, Modifier, Visibility, VisibleScope};
 use crate::{
@@ -59,18 +56,15 @@ pub struct Checker<'a> {
     noqa: flags::Noqa,
     pub(crate) settings: &'a Settings,
     pub(crate) noqa_line_for: &'a IntMap<usize, usize>,
-    pub(crate) locator: &'a SourceCodeLocator<'a>,
-    pub(crate) style: &'a SourceCodeStyleDetector<'a>,
+    pub(crate) locator: &'a Locator<'a>,
+    pub(crate) style: &'a Stylist<'a>,
     // Computed diagnostics.
     pub(crate) diagnostics: Vec<Diagnostic>,
     // Function and class definition tracking (e.g., for docstring enforcement).
-    definitions: Vec<(Definition<'a>, Visibility)>,
+    definitions: Vec<(Definition<'a>, Visibility, DeferralContext<'a>)>,
     // Edit tracking.
     // TODO(charlie): Instead of exposing deletions, wrap in a public API.
     pub(crate) deletions: FxHashSet<RefEquality<'a, Stmt>>,
-    // Import tracking.
-    pub(crate) from_imports: FxHashMap<&'a str, FxHashSet<&'a str>>,
-    pub(crate) import_aliases: FxHashMap<&'a str, &'a str>,
     // Retain all scopes and parent nodes, along with a stack of indexes to track which are active
     // at various points in time.
     pub(crate) parents: Vec<RefEquality<'a, Stmt>>,
@@ -110,8 +104,8 @@ impl<'a> Checker<'a> {
         autofix: flags::Autofix,
         noqa: flags::Noqa,
         path: &'a Path,
-        locator: &'a SourceCodeLocator,
-        style: &'a SourceCodeStyleDetector,
+        locator: &'a Locator,
+        style: &'a Stylist,
     ) -> Checker<'a> {
         Checker {
             settings,
@@ -124,8 +118,6 @@ impl<'a> Checker<'a> {
             diagnostics: vec![],
             definitions: vec![],
             deletions: FxHashSet::default(),
-            from_imports: FxHashMap::default(),
-            import_aliases: FxHashMap::default(),
             parents: vec![],
             depths: FxHashMap::default(),
             child_to_parent: FxHashMap::default(),
@@ -168,28 +160,28 @@ impl<'a> Checker<'a> {
 
     /// Return `true` if the `Expr` is a reference to `typing.${target}`.
     pub fn match_typing_expr(&self, expr: &Expr, target: &str) -> bool {
-        let call_path = dealias_call_path(collect_call_paths(expr), &self.import_aliases);
-        self.match_typing_call_path(&call_path, target)
+        self.resolve_call_path(expr).map_or(false, |call_path| {
+            self.match_typing_call_path(&call_path, target)
+        })
     }
 
     /// Return `true` if the call path is a reference to `typing.${target}`.
     pub fn match_typing_call_path(&self, call_path: &[&str], target: &str) -> bool {
-        if match_call_path(call_path, "typing", target, &self.from_imports) {
+        if call_path == ["typing", target] {
             return true;
         }
 
         if typing::TYPING_EXTENSIONS.contains(target) {
-            if match_call_path(call_path, "typing_extensions", target, &self.from_imports) {
+            if call_path == ["typing_extensions", target] {
                 return true;
             }
         }
 
-        if self
-            .settings
-            .typing_modules
-            .iter()
-            .any(|module| match_call_path(call_path, module, target, &self.from_imports))
-        {
+        if self.settings.typing_modules.iter().any(|module| {
+            let mut module = module.split('.').collect::<Vec<_>>();
+            module.push(target);
+            call_path == module.as_slice()
+        }) {
             return true;
         }
 
@@ -210,6 +202,54 @@ impl<'a> Checker<'a> {
         })
     }
 
+    pub fn resolve_call_path<'b>(&'a self, value: &'b Expr) -> Option<Vec<&'a str>>
+    where
+        'b: 'a,
+    {
+        let call_path = collect_call_path(value);
+        if let Some(head) = call_path.first() {
+            if let Some(binding) = self.find_binding(head) {
+                match &binding.kind {
+                    BindingKind::Importation(.., name) => {
+                        // Ignore relative imports.
+                        if name.starts_with('.') {
+                            return None;
+                        }
+                        let mut source_path: Vec<&str> = name.split('.').collect();
+                        source_path.extend(call_path.iter().skip(1));
+                        return Some(source_path);
+                    }
+                    BindingKind::SubmoduleImportation(name, ..) => {
+                        // Ignore relative imports.
+                        if name.starts_with('.') {
+                            return None;
+                        }
+                        let mut source_path: Vec<&str> = name.split('.').collect();
+                        source_path.extend(call_path.iter().skip(1));
+                        return Some(source_path);
+                    }
+                    BindingKind::FromImportation(.., name) => {
+                        // Ignore relative imports.
+                        if name.starts_with('.') {
+                            return None;
+                        }
+                        let mut source_path: Vec<&str> = name.split('.').collect();
+                        source_path.extend(call_path.iter().skip(1));
+                        return Some(source_path);
+                    }
+                    BindingKind::Builtin => {
+                        let mut source_path: Vec<&str> = Vec::with_capacity(call_path.len() + 1);
+                        source_path.push("");
+                        source_path.extend(call_path);
+                        return Some(source_path);
+                    }
+                    _ => {}
+                }
+            }
+        }
+        None
+    }
+
     /// Return `true` if a `RuleCode` is disabled by a `noqa` directive.
     pub fn is_ignored(&self, code: &RuleCode, lineno: usize) -> bool {
         // TODO(charlie): `noqa` directives are mostly enforced in `check_lines.rs`.
@@ -416,13 +456,11 @@ where
                 if self.settings.enabled.contains(&RuleCode::N804) {
                     if let Some(diagnostic) =
                         pep8_naming::rules::invalid_first_argument_name_for_class_method(
+                            self,
                             self.current_scope(),
                             name,
                             decorator_list,
                             args,
-                            &self.from_imports,
-                            &self.import_aliases,
-                            &self.settings.pep8_naming,
                         )
                     {
                         self.diagnostics.push(diagnostic);
@@ -432,13 +470,11 @@ where
                 if self.settings.enabled.contains(&RuleCode::N805) {
                     if let Some(diagnostic) =
                         pep8_naming::rules::invalid_first_argument_name_for_method(
+                            self,
                             self.current_scope(),
                             name,
                             decorator_list,
                             args,
-                            &self.from_imports,
-                            &self.import_aliases,
-                            &self.settings.pep8_naming,
                         )
                     {
                         self.diagnostics.push(diagnostic);
@@ -707,10 +743,7 @@ where
                         self.add_binding(
                             name,
                             Binding {
-                                kind: BindingKind::SubmoduleImportation(
-                                    name.to_string(),
-                                    full_name.to_string(),
-                                ),
+                                kind: BindingKind::SubmoduleImportation(name, full_name),
                                 used: None,
                                 range: Range::from_located(alias),
                                 source: Some(self.current_stmt().clone()),
@@ -729,10 +762,7 @@ where
                         self.add_binding(
                             name,
                             Binding {
-                                kind: BindingKind::Importation(
-                                    name.to_string(),
-                                    full_name.to_string(),
-                                ),
+                                kind: BindingKind::Importation(name, full_name),
                                 // Treat explicit re-export as usage (e.g., `import applications
                                 // as applications`).
                                 used: if alias
@@ -789,12 +819,6 @@ where
                     }
 
                     if let Some(asname) = &alias.node.asname {
-                        for alias in names {
-                            if let Some(asname) = &alias.node.asname {
-                                self.import_aliases.insert(asname, &alias.node.name);
-                            }
-                        }
-
                         let name = alias.node.name.split('.').last().unwrap();
                         if self.settings.enabled.contains(&RuleCode::N811) {
                             if let Some(diagnostic) =
@@ -891,25 +915,6 @@ where
                 module,
                 level,
             } => {
-                // Track `import from` statements, to ensure that we can correctly attribute
-                // references like `from typing import Union`.
-                if self.settings.enabled.contains(&RuleCode::UP023) {
-                    pyupgrade::rules::replace_c_element_tree(self, stmt);
-                }
-                if level.map(|level| level == 0).unwrap_or(true) {
-                    if let Some(module) = module {
-                        self.from_imports
-                            .entry(module)
-                            .or_insert_with(FxHashSet::default)
-                            .extend(names.iter().map(|alias| alias.node.name.as_str()));
-                    }
-                    for alias in names {
-                        if let Some(asname) = &alias.node.asname {
-                            self.import_aliases.insert(asname, &alias.node.name);
-                        }
-                    }
-                }
-
                 if self.settings.enabled.contains(&RuleCode::E402) {
                     if self.seen_import_boundary && stmt.location.column() == 0 {
                         self.diagnostics.push(Diagnostic::new(
@@ -927,6 +932,9 @@ where
                 if self.settings.enabled.contains(&RuleCode::UP026) {
                     pyupgrade::rules::rewrite_mock_import(self, stmt);
                 }
+                if self.settings.enabled.contains(&RuleCode::UP023) {
+                    pyupgrade::rules::replace_c_element_tree(self, stmt);
+                }
                 if self.settings.enabled.contains(&RuleCode::UP029) {
                     if let Some(module) = module.as_deref() {
                         pyupgrade::rules::unnecessary_builtin_import(self, stmt, module, names);
@@ -1058,15 +1066,16 @@ where
                         // be "foo.bar". Given `from foo import bar as baz`, `name` would be "baz"
                         // and `full_name` would be "foo.bar".
                         let name = alias.node.asname.as_ref().unwrap_or(&alias.node.name);
-                        let full_name = match module {
-                            None => alias.node.name.to_string(),
-                            Some(parent) => format!("{parent}.{}", alias.node.name),
-                        };
+                        let full_name = helpers::format_import_from_member(
+                            level.as_ref(),
+                            module.as_deref(),
+                            &alias.node.name,
+                        );
                         let range = Range::from_located(alias);
                         self.add_binding(
                             name,
                             Binding {
-                                kind: BindingKind::FromImportation(name.to_string(), full_name),
+                                kind: BindingKind::FromImportation(name, full_name),
                                 // Treat explicit re-export as usage (e.g., `from .applications
                                 // import FastAPI as FastAPI`).
                                 used: if alias
@@ -1311,8 +1320,15 @@ where
                 if self.settings.enabled.contains(&RuleCode::PLW0120) {
                     pylint::rules::useless_else_on_loop(self, stmt, body, orelse);
                 }
-                if self.settings.enabled.contains(&RuleCode::SIM118) {
-                    flake8_simplify::rules::key_in_dict_for(self, target, iter);
+                if matches!(stmt.node, StmtKind::For { .. }) {
+                    if self.settings.enabled.contains(&RuleCode::SIM110)
+                        || self.settings.enabled.contains(&RuleCode::SIM111)
+                    {
+                        flake8_simplify::rules::convert_for_loop_to_any_all(self, stmt, None);
+                    }
+                    if self.settings.enabled.contains(&RuleCode::SIM118) {
+                        flake8_simplify::rules::key_in_dict_for(self, target, iter);
+                    }
                 }
             }
             StmtKind::Try {
@@ -1447,8 +1463,11 @@ where
                     pyupgrade::rules::rewrite_yield_from(self, stmt);
                 }
                 let scope = transition_scope(&self.visible_scope, stmt, &Documentable::Function);
-                self.definitions
-                    .push((definition, scope.visibility.clone()));
+                self.definitions.push((
+                    definition,
+                    scope.visibility.clone(),
+                    (self.scope_stack.clone(), self.parents.clone()),
+                ));
                 self.visible_scope = scope;
 
                 // If any global bindings don't already exist in the global scope, add it.
@@ -1505,8 +1524,11 @@ where
                     &Documentable::Class,
                 );
                 let scope = transition_scope(&self.visible_scope, stmt, &Documentable::Class);
-                self.definitions
-                    .push((definition, scope.visibility.clone()));
+                self.definitions.push((
+                    definition,
+                    scope.visibility.clone(),
+                    (self.scope_stack.clone(), self.parents.clone()),
+                ));
                 self.visible_scope = scope;
 
                 // If any global bindings don't already exist in the global scope, add it.
@@ -1702,13 +1724,9 @@ where
                                     && !self.settings.pyupgrade.keep_runtime_typing
                                     && self.annotations_future_enabled
                                     && self.in_annotation))
-                            && typing::is_pep585_builtin(
-                                expr,
-                                &self.from_imports,
-                                &self.import_aliases,
-                            )
+                            && typing::is_pep585_builtin(self, expr)
                         {
-                            pyupgrade::rules::use_pep585_annotation(self, expr, id);
+                            pyupgrade::rules::use_pep585_annotation(self, expr);
                         }
 
                         self.handle_node_load(expr);
@@ -1746,9 +1764,9 @@ where
                         || (self.settings.target_version >= PythonVersion::Py37
                             && self.annotations_future_enabled
                             && self.in_annotation))
-                    && typing::is_pep585_builtin(expr, &self.from_imports, &self.import_aliases)
+                    && typing::is_pep585_builtin(self, expr)
                 {
-                    pyupgrade::rules::use_pep585_annotation(self, expr, attr);
+                    pyupgrade::rules::use_pep585_annotation(self, expr);
                 }
 
                 if self.settings.enabled.contains(&RuleCode::UP016) {
@@ -1816,12 +1834,7 @@ where
                 }
 
                 if self.settings.enabled.contains(&RuleCode::TID251) {
-                    flake8_tidy_imports::rules::banned_attribute_access(
-                        self,
-                        &dealias_call_path(collect_call_paths(expr), &self.import_aliases),
-                        expr,
-                        &self.settings.flake8_tidy_imports.banned_api,
-                    );
+                    flake8_tidy_imports::rules::banned_attribute_access(self, expr);
                 }
             }
             ExprKind::Call {
@@ -1970,85 +1983,36 @@ where
                     }
                 }
                 if self.settings.enabled.contains(&RuleCode::S103) {
-                    if let Some(diagnostic) = flake8_bandit::rules::bad_file_permissions(
-                        func,
-                        args,
-                        keywords,
-                        &self.from_imports,
-                        &self.import_aliases,
-                    ) {
-                        self.diagnostics.push(diagnostic);
-                    }
+                    flake8_bandit::rules::bad_file_permissions(self, func, args, keywords);
                 }
                 if self.settings.enabled.contains(&RuleCode::S501) {
-                    if let Some(diagnostic) = flake8_bandit::rules::request_with_no_cert_validation(
-                        func,
-                        args,
-                        keywords,
-                        &self.from_imports,
-                        &self.import_aliases,
-                    ) {
-                        self.diagnostics.push(diagnostic);
-                    }
+                    flake8_bandit::rules::request_with_no_cert_validation(
+                        self, func, args, keywords,
+                    );
                 }
                 if self.settings.enabled.contains(&RuleCode::S506) {
-                    if let Some(diagnostic) = flake8_bandit::rules::unsafe_yaml_load(
-                        func,
-                        args,
-                        keywords,
-                        &self.from_imports,
-                        &self.import_aliases,
-                    ) {
-                        self.diagnostics.push(diagnostic);
-                    }
+                    flake8_bandit::rules::unsafe_yaml_load(self, func, args, keywords);
                 }
                 if self.settings.enabled.contains(&RuleCode::S508) {
-                    if let Some(diagnostic) = flake8_bandit::rules::snmp_insecure_version(
-                        func,
-                        args,
-                        keywords,
-                        &self.from_imports,
-                        &self.import_aliases,
-                    ) {
-                        self.diagnostics.push(diagnostic);
-                    }
+                    flake8_bandit::rules::snmp_insecure_version(self, func, args, keywords);
                 }
                 if self.settings.enabled.contains(&RuleCode::S509) {
-                    if let Some(diagnostic) = flake8_bandit::rules::snmp_weak_cryptography(
-                        func,
-                        args,
-                        keywords,
-                        &self.from_imports,
-                        &self.import_aliases,
-                    ) {
-                        self.diagnostics.push(diagnostic);
-                    }
+                    flake8_bandit::rules::snmp_weak_cryptography(self, func, args, keywords);
+                }
+                if self.settings.enabled.contains(&RuleCode::S701) {
+                    flake8_bandit::rules::jinja2_autoescape_false(self, func, args, keywords);
                 }
                 if self.settings.enabled.contains(&RuleCode::S106) {
                     self.diagnostics
                         .extend(flake8_bandit::rules::hardcoded_password_func_arg(keywords));
                 }
                 if self.settings.enabled.contains(&RuleCode::S324) {
-                    if let Some(diagnostic) = flake8_bandit::rules::hashlib_insecure_hash_functions(
-                        func,
-                        args,
-                        keywords,
-                        &self.from_imports,
-                        &self.import_aliases,
-                    ) {
-                        self.diagnostics.push(diagnostic);
-                    }
+                    flake8_bandit::rules::hashlib_insecure_hash_functions(
+                        self, func, args, keywords,
+                    );
                 }
                 if self.settings.enabled.contains(&RuleCode::S113) {
-                    if let Some(diagnostic) = flake8_bandit::rules::request_without_timeout(
-                        func,
-                        args,
-                        keywords,
-                        &self.from_imports,
-                        &self.import_aliases,
-                    ) {
-                        self.diagnostics.push(diagnostic);
-                    }
+                    flake8_bandit::rules::request_without_timeout(self, func, args, keywords);
                 }
 
                 // flake8-comprehensions
@@ -2140,14 +2104,7 @@ where
 
                 // flake8-debugger
                 if self.settings.enabled.contains(&RuleCode::T100) {
-                    if let Some(diagnostic) = flake8_debugger::rules::debugger_call(
-                        expr,
-                        func,
-                        &self.from_imports,
-                        &self.import_aliases,
-                    ) {
-                        self.diagnostics.push(diagnostic);
-                    }
+                    flake8_debugger::rules::debugger_call(self, expr, func);
                 }
 
                 // pandas-vet
@@ -2174,7 +2131,7 @@ where
                                             if let BindingKind::Importation(.., module) =
                                                 &binding.kind
                                             {
-                                                module != "pandas"
+                                                module != &"pandas"
                                             } else {
                                                 matches!(
                                                     binding.kind,
@@ -2573,6 +2530,14 @@ where
                     );
                 }
 
+                if self.settings.enabled.contains(&RuleCode::PLR0133) {
+                    pylint::rules::constant_comparison(self, left, ops, comparators);
+                }
+
+                if self.settings.enabled.contains(&RuleCode::PLR2004) {
+                    pylint::rules::magic_value_comparison(self, left, comparators);
+                }
+
                 if self.settings.enabled.contains(&RuleCode::SIM118) {
                     flake8_simplify::rules::key_in_dict_compare(self, expr, left, ops, comparators);
                 }
@@ -2722,15 +2687,19 @@ where
                 args,
                 keywords,
             } => {
-                let call_path = dealias_call_path(collect_call_paths(func), &self.import_aliases);
-                if self.match_typing_call_path(&call_path, "ForwardRef") {
+                let call_path = self.resolve_call_path(func);
+                if call_path.as_ref().map_or(false, |call_path| {
+                    self.match_typing_call_path(call_path, "ForwardRef")
+                }) {
                     self.visit_expr(func);
                     for expr in args {
                         self.in_type_definition = true;
                         self.visit_expr(expr);
                         self.in_type_definition = prev_in_type_definition;
                     }
-                } else if self.match_typing_call_path(&call_path, "cast") {
+                } else if call_path.as_ref().map_or(false, |call_path| {
+                    self.match_typing_call_path(call_path, "cast")
+                }) {
                     self.visit_expr(func);
                     if !args.is_empty() {
                         self.in_type_definition = true;
@@ -2740,14 +2709,18 @@ where
                     for expr in args.iter().skip(1) {
                         self.visit_expr(expr);
                     }
-                } else if self.match_typing_call_path(&call_path, "NewType") {
+                } else if call_path.as_ref().map_or(false, |call_path| {
+                    self.match_typing_call_path(call_path, "NewType")
+                }) {
                     self.visit_expr(func);
                     for expr in args.iter().skip(1) {
                         self.in_type_definition = true;
                         self.visit_expr(expr);
                         self.in_type_definition = prev_in_type_definition;
                     }
-                } else if self.match_typing_call_path(&call_path, "TypeVar") {
+                } else if call_path.as_ref().map_or(false, |call_path| {
+                    self.match_typing_call_path(call_path, "TypeVar")
+                }) {
                     self.visit_expr(func);
                     for expr in args.iter().skip(1) {
                         self.in_type_definition = true;
@@ -2768,7 +2741,9 @@ where
                             }
                         }
                     }
-                } else if self.match_typing_call_path(&call_path, "NamedTuple") {
+                } else if call_path.as_ref().map_or(false, |call_path| {
+                    self.match_typing_call_path(call_path, "NamedTuple")
+                }) {
                     self.visit_expr(func);
 
                     // Ex) NamedTuple("a", [("a", int)])
@@ -2804,7 +2779,9 @@ where
                         self.visit_expr(value);
                         self.in_type_definition = prev_in_type_definition;
                     }
-                } else if self.match_typing_call_path(&call_path, "TypedDict") {
+                } else if call_path.as_ref().map_or(false, |call_path| {
+                    self.match_typing_call_path(call_path, "TypedDict")
+                }) {
                     self.visit_expr(func);
 
                     // Ex) TypedDict("a", {"a": int})
@@ -2830,12 +2807,11 @@ where
                         self.visit_expr(value);
                         self.in_type_definition = prev_in_type_definition;
                     }
-                } else if ["Arg", "DefaultArg", "NamedArg", "DefaultNamedArg"]
-                    .iter()
-                    .any(|target| {
-                        match_call_path(&call_path, "mypy_extensions", target, &self.from_imports)
-                    })
-                {
+                } else if call_path.as_ref().map_or(false, |call_path| {
+                    ["Arg", "DefaultArg", "NamedArg", "DefaultNamedArg"]
+                        .iter()
+                        .any(|target| *call_path == ["mypy_extensions", target])
+                }) {
                     self.visit_expr(func);
 
                     // Ex) DefaultNamedArg(bool | None, name="some_prop_name")
@@ -2869,13 +2845,7 @@ where
                     self.in_subscript = true;
                     visitor::walk_expr(self, expr);
                 } else {
-                    match typing::match_annotated_subscript(
-                        value,
-                        &self.from_imports,
-                        &self.import_aliases,
-                        self.settings.typing_modules.iter().map(String::as_str),
-                        |member| self.is_builtin(member),
-                    ) {
+                    match typing::match_annotated_subscript(self, value) {
                         Some(subscript) => {
                             match subscript {
                                 // Ex) Optional[int]
@@ -3158,7 +3128,7 @@ where
                 if matches!(stmt.node, StmtKind::For { .. })
                     && matches!(sibling.node, StmtKind::Return { .. })
                 {
-                    flake8_simplify::rules::convert_loop_to_any_all(self, stmt, sibling);
+                    flake8_simplify::rules::convert_for_loop_to_any_all(self, stmt, Some(sibling));
                 }
             }
         }
@@ -3238,16 +3208,6 @@ impl<'a> Checker<'a> {
         self.parents.iter().rev().nth(1)
     }
 
-    /// Return the grandparent `Stmt` of the current `Stmt`, if any.
-    pub fn current_stmt_grandparent(&self) -> Option<&RefEquality<'a, Stmt>> {
-        self.parents.iter().rev().nth(2)
-    }
-
-    /// Return the current `Expr`.
-    pub fn current_expr(&self) -> Option<&RefEquality<'a, Expr>> {
-        self.exprs.iter().rev().next()
-    }
-
     /// Return the parent `Expr` of the current `Expr`.
     pub fn current_expr_parent(&self) -> Option<&RefEquality<'a, Expr>> {
         self.exprs.iter().rev().nth(1)
@@ -3412,23 +3372,37 @@ impl<'a> Checker<'a> {
                     //   import pyarrow as pa
                     //   import pyarrow.csv
                     //   print(pa.csv.read_csv("test.csv"))
-                    if let BindingKind::Importation(name, full_name)
-                    | BindingKind::FromImportation(name, full_name)
-                    | BindingKind::SubmoduleImportation(name, full_name) =
-                        &self.bindings[*index].kind
-                    {
-                        let has_alias = full_name
-                            .split('.')
-                            .last()
-                            .map(|segment| segment != name)
-                            .unwrap_or_default();
-                        if has_alias {
-                            // Mark the sub-importation as used.
-                            if let Some(index) = scope.values.get(full_name.as_str()) {
-                                self.bindings[*index].used =
-                                    Some((scope_id, Range::from_located(expr)));
+                    match &self.bindings[*index].kind {
+                        BindingKind::Importation(name, full_name)
+                        | BindingKind::SubmoduleImportation(name, full_name) => {
+                            let has_alias = full_name
+                                .split('.')
+                                .last()
+                                .map(|segment| &segment != name)
+                                .unwrap_or_default();
+                            if has_alias {
+                                // Mark the sub-importation as used.
+                                if let Some(index) = scope.values.get(full_name) {
+                                    self.bindings[*index].used =
+                                        Some((scope_id, Range::from_located(expr)));
+                                }
                             }
                         }
+                        BindingKind::FromImportation(name, full_name) => {
+                            let has_alias = full_name
+                                .split('.')
+                                .last()
+                                .map(|segment| &segment != name)
+                                .unwrap_or_default();
+                            if has_alias {
+                                // Mark the sub-importation as used.
+                                if let Some(index) = scope.values.get(full_name.as_str()) {
+                                    self.bindings[*index].used =
+                                        Some((scope_id, Range::from_located(expr)));
+                                }
+                            }
+                        }
+                        _ => {}
                     }
 
                     return;
@@ -3682,6 +3656,7 @@ impl<'a> Checker<'a> {
                 docstring,
             },
             self.visible_scope.visibility.clone(),
+            (self.scope_stack.clone(), self.parents.clone()),
         ));
         docstring.is_some()
     }
@@ -3953,9 +3928,12 @@ impl<'a> Checker<'a> {
                 {
                     let binding = &self.bindings[*index];
 
-                    let (BindingKind::Importation(_, full_name)
-                    | BindingKind::SubmoduleImportation(_, full_name)
-                    | BindingKind::FromImportation(_, full_name)) = &binding.kind else { continue; };
+                    let full_name = match &binding.kind {
+                        BindingKind::Importation(.., full_name) => full_name,
+                        BindingKind::FromImportation(.., full_name) => full_name.as_str(),
+                        BindingKind::SubmoduleImportation(.., full_name) => full_name,
+                        _ => continue,
+                    };
 
                     // Skip used exports from `__all__`
                     if binding.used.is_some()
@@ -4135,7 +4113,10 @@ impl<'a> Checker<'a> {
 
         let mut overloaded_name: Option<String> = None;
         self.definitions.reverse();
-        while let Some((definition, visibility)) = self.definitions.pop() {
+        while let Some((definition, visibility, (scopes, parents))) = self.definitions.pop() {
+            self.scope_stack = scopes.clone();
+            self.parents = parents.clone();
+
             // flake8-annotations
             if enforce_annotations {
                 // TODO(charlie): This should be even stricter, in that an overload
@@ -4308,8 +4289,8 @@ impl<'a> Checker<'a> {
 #[allow(clippy::too_many_arguments)]
 pub fn check_ast(
     python_ast: &Suite,
-    locator: &SourceCodeLocator,
-    stylist: &SourceCodeStyleDetector,
+    locator: &Locator,
+    stylist: &Stylist,
     noqa_line_for: &IntMap<usize, usize>,
     settings: &Settings,
     autofix: flags::Autofix,
@@ -4348,13 +4329,13 @@ pub fn check_ast(
     let mut allocator = vec![];
     checker.check_deferred_string_type_definitions(&mut allocator);
 
+    // Check docstrings.
+    checker.check_definitions();
+
     // Reset the scope to module-level, and check all consumed scopes.
     checker.scope_stack = vec![GLOBAL_SCOPE_INDEX];
     checker.pop_scope();
     checker.check_dead_scopes();
 
-    // Check docstrings.
-    checker.check_definitions();
-
     checker.diagnostics
 }

src/checkers/imports.rs

@@ -10,16 +10,15 @@ use crate::isort;
 use crate::isort::track::{Block, ImportTracker};
 use crate::registry::{Diagnostic, RuleCode};
 use crate::settings::{flags, Settings};
-use crate::source_code_locator::SourceCodeLocator;
-use crate::source_code_style::SourceCodeStyleDetector;
+use crate::source_code::{Locator, Stylist};
 
 #[allow(clippy::too_many_arguments)]
 pub fn check_imports(
     python_ast: &Suite,
-    locator: &SourceCodeLocator,
+    locator: &Locator,
     directives: &IsortDirectives,
     settings: &Settings,
-    stylist: &SourceCodeStyleDetector,
+    stylist: &Stylist,
     autofix: flags::Autofix,
     path: &Path,
     package: Option<&Path>,

src/checkers/noqa.rs

@@ -6,7 +6,7 @@ use nohash_hasher::IntMap;
 use rustpython_parser::ast::Location;
 
 use crate::ast::types::Range;
-use crate::autofix::Fix;
+use crate::fix::Fix;
 use crate::noqa::{is_file_exempt, Directive};
 use crate::registry::{Diagnostic, DiagnosticKind, RuleCode, CODE_REDIRECTS};
 use crate::settings::{flags, Settings};

src/checkers/tokens.rs

@@ -5,12 +5,12 @@ use rustpython_parser::lexer::{LexResult, Tok};
 use crate::lex::docstring_detection::StateMachine;
 use crate::registry::{Diagnostic, RuleCode};
 use crate::ruff::rules::Context;
-use crate::settings::flags;
-use crate::source_code_locator::SourceCodeLocator;
-use crate::{eradicate, flake8_implicit_str_concat, flake8_quotes, pycodestyle, ruff, Settings};
+use crate::settings::{flags, Settings};
+use crate::source_code::Locator;
+use crate::{eradicate, flake8_implicit_str_concat, flake8_quotes, pycodestyle, ruff};
 
 pub fn check_tokens(
-    locator: &SourceCodeLocator,
+    locator: &Locator,
     tokens: &[LexResult],
     settings: &Settings,
     autofix: flags::Autofix,
@@ -67,7 +67,8 @@ pub fn check_tokens(
                     start,
                     end,
                     is_docstring,
-                    &settings.flake8_quotes,
+                    settings,
+                    autofix,
                 ) {
                     if settings.enabled.contains(diagnostic.kind.code()) {
                         diagnostics.push(diagnostic);

src/directives.rs

@@ -6,7 +6,7 @@ use rustpython_ast::Location;
 use rustpython_parser::lexer::{LexResult, Tok};
 
 use crate::registry::LintSource;
-use crate::Settings;
+use crate::settings::Settings;
 
 bitflags! {
     pub struct Flags: u32 {

src/eradicate/mod.rs

@@ -1,5 +1,5 @@
-pub mod detection;
-pub mod rules;
+pub(crate) mod detection;
+pub(crate) mod rules;
 
 #[cfg(test)]
 mod tests {

src/eradicate/rules.rs

@@ -1,11 +1,12 @@
 use rustpython_ast::Location;
 
 use crate::ast::types::Range;
-use crate::autofix::Fix;
 use crate::eradicate::detection::comment_contains_code;
-use crate::registry::RuleCode;
-use crate::settings::flags;
-use crate::{violations, Diagnostic, Settings, SourceCodeLocator};
+use crate::fix::Fix;
+use crate::registry::{Diagnostic, RuleCode};
+use crate::settings::{flags, Settings};
+use crate::source_code::Locator;
+use crate::violations;
 
 fn is_standalone_comment(line: &str) -> bool {
     for char in line.chars() {
@@ -20,7 +21,7 @@ fn is_standalone_comment(line: &str) -> bool {
 
 /// ERA001
 pub fn commented_out_code(
-    locator: &SourceCodeLocator,
+    locator: &Locator,
     start: Location,
     end: Location,
     settings: &Settings,

src/fix.rs

@@ -0,0 +1,53 @@
+use rustpython_ast::Location;
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Copy, Clone, Hash)]
+pub enum FixMode {
+    Generate,
+    Apply,
+    Diff,
+    None,
+}
+
+impl From<bool> for FixMode {
+    fn from(value: bool) -> Self {
+        if value {
+            FixMode::Apply
+        } else {
+            FixMode::None
+        }
+    }
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
+pub struct Fix {
+    pub content: String,
+    pub location: Location,
+    pub end_location: Location,
+}
+
+impl Fix {
+    pub fn deletion(start: Location, end: Location) -> Self {
+        Self {
+            content: String::new(),
+            location: start,
+            end_location: end,
+        }
+    }
+
+    pub fn replacement(content: String, start: Location, end: Location) -> Self {
+        Self {
+            content,
+            location: start,
+            end_location: end,
+        }
+    }
+
+    pub fn insertion(content: String, at: Location) -> Self {
+        Self {
+            content,
+            location: at,
+            end_location: at,
+        }
+    }
+}

src/flake8_2020/mod.rs

@@ -1,4 +1,4 @@
-pub mod rules;
+pub(crate) mod rules;
 
 #[cfg(test)]
 mod tests {

src/flake8_2020/rules.rs

@@ -1,20 +1,15 @@
 use num_bigint::BigInt;
 use rustpython_ast::{Cmpop, Constant, Expr, ExprKind, Located};
 
-use crate::ast::helpers::match_module_member;
 use crate::ast::types::Range;
 use crate::checkers::ast::Checker;
 use crate::registry::{Diagnostic, RuleCode};
 use crate::violations;
 
 fn is_sys(checker: &Checker, expr: &Expr, target: &str) -> bool {
-    match_module_member(
-        expr,
-        "sys",
-        target,
-        &checker.from_imports,
-        &checker.import_aliases,
-    )
+    checker
+        .resolve_call_path(expr)
+        .map_or(false, |path| path == ["sys", target])
 }
 
 /// YTT101, YTT102, YTT301, YTT303
@@ -187,13 +182,10 @@ pub fn compare(checker: &mut Checker, left: &Expr, ops: &[Cmpop], comparators: &
 
 /// YTT202
 pub fn name_or_attribute(checker: &mut Checker, expr: &Expr) {
-    if match_module_member(
-        expr,
-        "six",
-        "PY3",
-        &checker.from_imports,
-        &checker.import_aliases,
-    ) {
+    if checker
+        .resolve_call_path(expr)
+        .map_or(false, |path| path == ["six", "PY3"])
+    {
         checker.diagnostics.push(Diagnostic::new(
             violations::SixPY3Referenced,
             Range::from_located(expr),

src/flake8_annotations/fixes.rs

@@ -4,11 +4,11 @@ use rustpython_parser::lexer;
 use rustpython_parser::lexer::Tok;
 
 use crate::ast::types::Range;
-use crate::autofix::Fix;
-use crate::source_code_locator::SourceCodeLocator;
+use crate::fix::Fix;
+use crate::source_code::Locator;
 
 /// ANN204
-pub fn add_return_none_annotation(locator: &SourceCodeLocator, stmt: &Stmt) -> Result<Fix> {
+pub fn add_return_none_annotation(locator: &Locator, stmt: &Stmt) -> Result<Fix> {
     let range = Range::from_located(stmt);
     let contents = locator.slice_source_code_range(&range);
 

src/flake8_annotations/mod.rs

@@ -1,6 +1,6 @@
 mod fixes;
-pub mod helpers;
-pub mod rules;
+pub(crate) mod helpers;
+pub(crate) mod rules;
 pub mod settings;
 
 #[cfg(test)]
@@ -9,9 +9,10 @@ mod tests {
 
     use anyhow::Result;
 
+    use crate::flake8_annotations;
     use crate::linter::test_path;
     use crate::registry::RuleCode;
-    use crate::{flake8_annotations, Settings};
+    use crate::settings::Settings;
 
     #[test]
     fn defaults() -> Result<()> {
@@ -144,4 +145,22 @@ mod tests {
         insta::assert_yaml_snapshot!(diagnostics);
         Ok(())
     }
+
+    #[test]
+    fn allow_nested_overload() -> Result<()> {
+        let diagnostics = test_path(
+            Path::new("./resources/test/fixtures/flake8_annotations/allow_nested_overload.py"),
+            &Settings {
+                ..Settings::for_rules(vec![
+                    RuleCode::ANN201,
+                    RuleCode::ANN202,
+                    RuleCode::ANN204,
+                    RuleCode::ANN205,
+                    RuleCode::ANN206,
+                ])
+            },
+        )?;
+        insta::assert_yaml_snapshot!(diagnostics);
+        Ok(())
+    }
 }

src/flake8_annotations/rules.rs

@@ -8,9 +8,9 @@ use crate::checkers::ast::Checker;
 use crate::docstrings::definition::{Definition, DefinitionKind};
 use crate::flake8_annotations::fixes;
 use crate::flake8_annotations::helpers::match_function_def;
-use crate::registry::RuleCode;
+use crate::registry::{Diagnostic, RuleCode};
 use crate::visibility::Visibility;
-use crate::{violations, visibility, Diagnostic};
+use crate::{violations, visibility};
 
 #[derive(Default)]
 struct ReturnStatementVisitor<'a> {

src/flake8_annotations/snapshots/ruff__flake8_annotations__tests__allow_nested_overload.snap

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

src/flake8_bandit/mod.rs

@@ -1,5 +1,5 @@
 mod helpers;
-pub mod rules;
+pub(crate) mod rules;
 pub mod settings;
 
 #[cfg(test)]
@@ -9,9 +9,10 @@ mod tests {
     use anyhow::Result;
     use test_case::test_case;
 
+    use crate::flake8_bandit;
     use crate::linter::test_path;
     use crate::registry::RuleCode;
-    use crate::{flake8_bandit, Settings};
+    use crate::settings::Settings;
 
     #[test_case(RuleCode::S101, Path::new("S101.py"); "S101")]
     #[test_case(RuleCode::S102, Path::new("S102.py"); "S102")]
@@ -27,6 +28,7 @@ mod tests {
     #[test_case(RuleCode::S506, Path::new("S506.py"); "S506")]
     #[test_case(RuleCode::S508, Path::new("S508.py"); "S508")]
     #[test_case(RuleCode::S509, Path::new("S509.py"); "S509")]
+    #[test_case(RuleCode::S701, Path::new("S701.py"); "S701")]
     fn rules(rule_code: RuleCode, path: &Path) -> Result<()> {
         let snapshot = format!("{}_{}", rule_code.as_ref(), path.to_string_lossy());
         let diagnostics = test_path(

src/flake8_bandit/rules/bad_file_permissions.rs

@@ -1,10 +1,11 @@
 use num_traits::ToPrimitive;
 use once_cell::sync::Lazy;
-use rustc_hash::{FxHashMap, FxHashSet};
+use rustc_hash::FxHashMap;
 use rustpython_ast::{Constant, Expr, ExprKind, Keyword, Operator};
 
-use crate::ast::helpers::{compose_call_path, match_module_member, SimpleCallArgs};
+use crate::ast::helpers::{compose_call_path, SimpleCallArgs};
 use crate::ast::types::Range;
+use crate::checkers::ast::Checker;
 use crate::registry::Diagnostic;
 use crate::violations;
 
@@ -86,18 +87,20 @@ fn get_int_value(expr: &Expr) -> Option<u16> {
 
 /// S103
 pub fn bad_file_permissions(
+    checker: &mut Checker,
     func: &Expr,
     args: &[Expr],
     keywords: &[Keyword],
-    from_imports: &FxHashMap<&str, FxHashSet<&str>>,
-    import_aliases: &FxHashMap<&str, &str>,
-) -> Option<Diagnostic> {
-    if match_module_member(func, "os", "chmod", from_imports, import_aliases) {
+) {
+    if checker
+        .resolve_call_path(func)
+        .map_or(false, |call_path| call_path == ["os", "chmod"])
+    {
         let call_args = SimpleCallArgs::new(args, keywords);
         if let Some(mode_arg) = call_args.get_argument("mode", Some(1)) {
             if let Some(int_value) = get_int_value(mode_arg) {
                 if (int_value & WRITE_WORLD > 0) || (int_value & EXECUTE_GROUP > 0) {
-                    return Some(Diagnostic::new(
+                    checker.diagnostics.push(Diagnostic::new(
                         violations::BadFilePermissions(int_value),
                         Range::from_located(mode_arg),
                     ));
@@ -105,5 +108,4 @@ pub fn bad_file_permissions(
             }
         }
     }
-    None
 }

src/flake8_bandit/rules/hashlib_insecure_hash_functions.rs

@@ -1,8 +1,8 @@
-use rustc_hash::{FxHashMap, FxHashSet};
 use rustpython_ast::{Constant, Expr, ExprKind, Keyword};
 
-use crate::ast::helpers::{match_module_member, SimpleCallArgs};
+use crate::ast::helpers::SimpleCallArgs;
 use crate::ast::types::Range;
+use crate::checkers::ast::Checker;
 use crate::flake8_bandit::helpers::string_literal;
 use crate::registry::Diagnostic;
 use crate::violations;
@@ -24,44 +24,45 @@ fn is_used_for_security(call_args: &SimpleCallArgs) -> bool {
 
 /// S324
 pub fn hashlib_insecure_hash_functions(
+    checker: &mut Checker,
     func: &Expr,
     args: &[Expr],
     keywords: &[Keyword],
-    from_imports: &FxHashMap<&str, FxHashSet<&str>>,
-    import_aliases: &FxHashMap<&str, &str>,
-) -> Option<Diagnostic> {
-    if match_module_member(func, "hashlib", "new", from_imports, import_aliases) {
-        let call_args = SimpleCallArgs::new(args, keywords);
+) {
+    if let Some(call_path) = checker.resolve_call_path(func) {
+        if call_path == ["hashlib", "new"] {
+            let call_args = SimpleCallArgs::new(args, keywords);
 
-        if !is_used_for_security(&call_args) {
-            return None;
-        }
-
-        if let Some(name_arg) = call_args.get_argument("name", Some(0)) {
-            let hash_func_name = string_literal(name_arg)?;
-
-            if WEAK_HASHES.contains(&hash_func_name.to_lowercase().as_str()) {
-                return Some(Diagnostic::new(
-                    violations::HashlibInsecureHashFunction(hash_func_name.to_string()),
-                    Range::from_located(name_arg),
-                ));
+            if !is_used_for_security(&call_args) {
+                return;
             }
-        }
-    } else {
-        for func_name in &WEAK_HASHES {
-            if match_module_member(func, "hashlib", func_name, from_imports, import_aliases) {
-                let call_args = SimpleCallArgs::new(args, keywords);
 
-                if !is_used_for_security(&call_args) {
-                    return None;
+            if let Some(name_arg) = call_args.get_argument("name", Some(0)) {
+                if let Some(hash_func_name) = string_literal(name_arg) {
+                    if WEAK_HASHES.contains(&hash_func_name.to_lowercase().as_str()) {
+                        checker.diagnostics.push(Diagnostic::new(
+                            violations::HashlibInsecureHashFunction(hash_func_name.to_string()),
+                            Range::from_located(name_arg),
+                        ));
+                    }
                 }
+            }
+        } else {
+            for func_name in &WEAK_HASHES {
+                if call_path == ["hashlib", func_name] {
+                    let call_args = SimpleCallArgs::new(args, keywords);
 
-                return Some(Diagnostic::new(
-                    violations::HashlibInsecureHashFunction((*func_name).to_string()),
-                    Range::from_located(func),
-                ));
+                    if !is_used_for_security(&call_args) {
+                        return;
+                    }
+
+                    checker.diagnostics.push(Diagnostic::new(
+                        violations::HashlibInsecureHashFunction((*func_name).to_string()),
+                        Range::from_located(func),
+                    ));
+                    return;
+                }
             }
         }
     }
-    None
 }

src/flake8_bandit/rules/jinja2_autoescape_false.rs

@@ -0,0 +1,51 @@
+use rustpython_ast::{Expr, ExprKind, Keyword};
+use rustpython_parser::ast::Constant;
+
+use crate::ast::helpers::SimpleCallArgs;
+use crate::ast::types::Range;
+use crate::checkers::ast::Checker;
+use crate::registry::Diagnostic;
+use crate::violations;
+
+/// S701
+pub fn jinja2_autoescape_false(
+    checker: &mut Checker,
+    func: &Expr,
+    args: &[Expr],
+    keywords: &[Keyword],
+) {
+    if checker
+        .resolve_call_path(func)
+        .map_or(false, |call_path| call_path == ["jinja2", "Environment"])
+    {
+        let call_args = SimpleCallArgs::new(args, keywords);
+
+        if let Some(autoescape_arg) = call_args.get_argument("autoescape", None) {
+            match &autoescape_arg.node {
+                ExprKind::Constant {
+                    value: Constant::Bool(true),
+                    ..
+                } => (),
+                ExprKind::Call { func, .. } => {
+                    if let ExprKind::Name { id, .. } = &func.node {
+                        if id.as_str() != "select_autoescape" {
+                            checker.diagnostics.push(Diagnostic::new(
+                                violations::Jinja2AutoescapeFalse(true),
+                                Range::from_located(autoescape_arg),
+                            ));
+                        }
+                    }
+                }
+                _ => checker.diagnostics.push(Diagnostic::new(
+                    violations::Jinja2AutoescapeFalse(true),
+                    Range::from_located(autoescape_arg),
+                )),
+            }
+        } else {
+            checker.diagnostics.push(Diagnostic::new(
+                violations::Jinja2AutoescapeFalse(false),
+                Range::from_located(func),
+            ));
+        }
+    }
+}

src/flake8_bandit/rules/mod.rs

@@ -9,6 +9,7 @@ pub use hardcoded_password_string::{
 };
 pub use hardcoded_tmp_directory::hardcoded_tmp_directory;
 pub use hashlib_insecure_hash_functions::hashlib_insecure_hash_functions;
+pub use jinja2_autoescape_false::jinja2_autoescape_false;
 pub use request_with_no_cert_validation::request_with_no_cert_validation;
 pub use request_without_timeout::request_without_timeout;
 pub use snmp_insecure_version::snmp_insecure_version;
@@ -24,6 +25,7 @@ mod hardcoded_password_func_arg;
 mod hardcoded_password_string;
 mod hardcoded_tmp_directory;
 mod hashlib_insecure_hash_functions;
+mod jinja2_autoescape_false;
 mod request_with_no_cert_validation;
 mod request_without_timeout;
 mod snmp_insecure_version;

src/flake8_bandit/rules/request_with_no_cert_validation.rs

@@ -1,9 +1,9 @@
-use rustc_hash::{FxHashMap, FxHashSet};
 use rustpython_ast::{Expr, ExprKind, Keyword};
 use rustpython_parser::ast::Constant;
 
-use crate::ast::helpers::{collect_call_paths, dealias_call_path, match_call_path, SimpleCallArgs};
+use crate::ast::helpers::SimpleCallArgs;
 use crate::ast::types::Range;
+use crate::checkers::ast::Checker;
 use crate::registry::Diagnostic;
 use crate::violations;
 
@@ -24,47 +24,46 @@ const HTTPX_METHODS: [&str; 11] = [
 
 /// S501
 pub fn request_with_no_cert_validation(
+    checker: &mut Checker,
     func: &Expr,
     args: &[Expr],
     keywords: &[Keyword],
-    from_imports: &FxHashMap<&str, FxHashSet<&str>>,
-    import_aliases: &FxHashMap<&str, &str>,
-) -> Option<Diagnostic> {
-    let call_path = dealias_call_path(collect_call_paths(func), import_aliases);
-    let call_args = SimpleCallArgs::new(args, keywords);
-
-    for func_name in &REQUESTS_HTTP_VERBS {
-        if match_call_path(&call_path, "requests", func_name, from_imports) {
-            if let Some(verify_arg) = call_args.get_argument("verify", None) {
-                if let ExprKind::Constant {
-                    value: Constant::Bool(false),
-                    ..
-                } = &verify_arg.node
-                {
-                    return Some(Diagnostic::new(
-                        violations::RequestWithNoCertValidation("requests".to_string()),
-                        Range::from_located(verify_arg),
-                    ));
+) {
+    if let Some(call_path) = checker.resolve_call_path(func) {
+        let call_args = SimpleCallArgs::new(args, keywords);
+        for func_name in &REQUESTS_HTTP_VERBS {
+            if call_path == ["requests", func_name] {
+                if let Some(verify_arg) = call_args.get_argument("verify", None) {
+                    if let ExprKind::Constant {
+                        value: Constant::Bool(false),
+                        ..
+                    } = &verify_arg.node
+                    {
+                        checker.diagnostics.push(Diagnostic::new(
+                            violations::RequestWithNoCertValidation("requests".to_string()),
+                            Range::from_located(verify_arg),
+                        ));
+                    }
                 }
+                return;
+            }
+        }
+        for func_name in &HTTPX_METHODS {
+            if call_path == ["httpx", func_name] {
+                if let Some(verify_arg) = call_args.get_argument("verify", None) {
+                    if let ExprKind::Constant {
+                        value: Constant::Bool(false),
+                        ..
+                    } = &verify_arg.node
+                    {
+                        checker.diagnostics.push(Diagnostic::new(
+                            violations::RequestWithNoCertValidation("httpx".to_string()),
+                            Range::from_located(verify_arg),
+                        ));
+                    }
+                }
+                return;
             }
         }
     }
-
-    for func_name in &HTTPX_METHODS {
-        if match_call_path(&call_path, "httpx", func_name, from_imports) {
-            if let Some(verify_arg) = call_args.get_argument("verify", None) {
-                if let ExprKind::Constant {
-                    value: Constant::Bool(false),
-                    ..
-                } = &verify_arg.node
-                {
-                    return Some(Diagnostic::new(
-                        violations::RequestWithNoCertValidation("httpx".to_string()),
-                        Range::from_located(verify_arg),
-                    ));
-                }
-            }
-        }
-    }
-    None
 }

src/flake8_bandit/rules/request_without_timeout.rs

@@ -1,9 +1,9 @@
-use rustc_hash::{FxHashMap, FxHashSet};
 use rustpython_ast::{Expr, ExprKind, Keyword};
 use rustpython_parser::ast::Constant;
 
-use crate::ast::helpers::{collect_call_paths, dealias_call_path, match_call_path, SimpleCallArgs};
+use crate::ast::helpers::SimpleCallArgs;
 use crate::ast::types::Range;
+use crate::checkers::ast::Checker;
 use crate::registry::Diagnostic;
 use crate::violations;
 
@@ -11,36 +11,35 @@ const HTTP_VERBS: [&str; 7] = ["get", "options", "head", "post", "put", "patch",
 
 /// S113
 pub fn request_without_timeout(
+    checker: &mut Checker,
     func: &Expr,
     args: &[Expr],
     keywords: &[Keyword],
-    from_imports: &FxHashMap<&str, FxHashSet<&str>>,
-    import_aliases: &FxHashMap<&str, &str>,
-) -> Option<Diagnostic> {
-    let call_path = dealias_call_path(collect_call_paths(func), import_aliases);
-    for func_name in &HTTP_VERBS {
-        if match_call_path(&call_path, "requests", func_name, from_imports) {
-            let call_args = SimpleCallArgs::new(args, keywords);
-            if let Some(timeout_arg) = call_args.get_argument("timeout", None) {
-                if let Some(timeout) = match &timeout_arg.node {
-                    ExprKind::Constant {
-                        value: value @ Constant::None,
-                        ..
-                    } => Some(value.to_string()),
-                    _ => None,
-                } {
-                    return Some(Diagnostic::new(
-                        violations::RequestWithoutTimeout(Some(timeout)),
-                        Range::from_located(timeout_arg),
-                    ));
-                }
-            } else {
-                return Some(Diagnostic::new(
-                    violations::RequestWithoutTimeout(None),
-                    Range::from_located(func),
+) {
+    if checker.resolve_call_path(func).map_or(false, |call_path| {
+        HTTP_VERBS
+            .iter()
+            .any(|func_name| call_path == ["requests", func_name])
+    }) {
+        let call_args = SimpleCallArgs::new(args, keywords);
+        if let Some(timeout_arg) = call_args.get_argument("timeout", None) {
+            if let Some(timeout) = match &timeout_arg.node {
+                ExprKind::Constant {
+                    value: value @ Constant::None,
+                    ..
+                } => Some(value.to_string()),
+                _ => None,
+            } {
+                checker.diagnostics.push(Diagnostic::new(
+                    violations::RequestWithoutTimeout(Some(timeout)),
+                    Range::from_located(timeout_arg),
                 ));
             }
+        } else {
+            checker.diagnostics.push(Diagnostic::new(
+                violations::RequestWithoutTimeout(None),
+                Range::from_located(func),
+            ));
         }
     }
-    None
 }

src/flake8_bandit/rules/snmp_insecure_version.rs

@@ -1,26 +1,24 @@
 use num_traits::{One, Zero};
-use rustc_hash::{FxHashMap, FxHashSet};
 use rustpython_ast::{Expr, ExprKind, Keyword};
 use rustpython_parser::ast::Constant;
 
-use crate::ast::helpers::{collect_call_paths, dealias_call_path, match_call_path, SimpleCallArgs};
+use crate::ast::helpers::SimpleCallArgs;
 use crate::ast::types::Range;
+use crate::checkers::ast::Checker;
 use crate::registry::Diagnostic;
 use crate::violations;
 
 /// S508
 pub fn snmp_insecure_version(
+    checker: &mut Checker,
     func: &Expr,
     args: &[Expr],
     keywords: &[Keyword],
-    from_imports: &FxHashMap<&str, FxHashSet<&str>>,
-    import_aliases: &FxHashMap<&str, &str>,
-) -> Option<Diagnostic> {
-    let call_path = dealias_call_path(collect_call_paths(func), import_aliases);
-
-    if match_call_path(&call_path, "pysnmp.hlapi", "CommunityData", from_imports) {
+) {
+    if checker.resolve_call_path(func).map_or(false, |call_path| {
+        call_path == ["pysnmp", "hlapi", "CommunityData"]
+    }) {
         let call_args = SimpleCallArgs::new(args, keywords);
-
         if let Some(mp_model_arg) = call_args.get_argument("mpModel", None) {
             if let ExprKind::Constant {
                 value: Constant::Int(value),
@@ -28,7 +26,7 @@ pub fn snmp_insecure_version(
             } = &mp_model_arg.node
             {
                 if value.is_zero() || value.is_one() {
-                    return Some(Diagnostic::new(
+                    checker.diagnostics.push(Diagnostic::new(
                         violations::SnmpInsecureVersion,
                         Range::from_located(mp_model_arg),
                     ));
@@ -36,5 +34,4 @@ pub fn snmp_insecure_version(
             }
         }
     }
-    None
 }

src/flake8_bandit/rules/snmp_weak_cryptography.rs

@@ -1,30 +1,27 @@
-use rustc_hash::{FxHashMap, FxHashSet};
 use rustpython_ast::{Expr, Keyword};
 
-use crate::ast::helpers::{collect_call_paths, dealias_call_path, match_call_path, SimpleCallArgs};
+use crate::ast::helpers::SimpleCallArgs;
 use crate::ast::types::Range;
+use crate::checkers::ast::Checker;
 use crate::registry::Diagnostic;
 use crate::violations;
 
 /// S509
 pub fn snmp_weak_cryptography(
+    checker: &mut Checker,
     func: &Expr,
     args: &[Expr],
     keywords: &[Keyword],
-    from_imports: &FxHashMap<&str, FxHashSet<&str>>,
-    import_aliases: &FxHashMap<&str, &str>,
-) -> Option<Diagnostic> {
-    let call_path = dealias_call_path(collect_call_paths(func), import_aliases);
-
-    if match_call_path(&call_path, "pysnmp.hlapi", "UsmUserData", from_imports) {
+) {
+    if checker.resolve_call_path(func).map_or(false, |call_path| {
+        call_path == ["pysnmp", "hlapi", "UsmUserData"]
+    }) {
         let call_args = SimpleCallArgs::new(args, keywords);
-
         if call_args.len() < 3 {
-            return Some(Diagnostic::new(
+            checker.diagnostics.push(Diagnostic::new(
                 violations::SnmpWeakCryptography,
                 Range::from_located(func),
             ));
         }
     }
-    None
 }

src/flake8_bandit/rules/unsafe_yaml_load.rs

@@ -1,51 +1,40 @@
-use rustc_hash::{FxHashMap, FxHashSet};
 use rustpython_ast::{Expr, ExprKind, Keyword};
 
-use crate::ast::helpers::{match_module_member, SimpleCallArgs};
+use crate::ast::helpers::SimpleCallArgs;
 use crate::ast::types::Range;
+use crate::checkers::ast::Checker;
 use crate::registry::Diagnostic;
 use crate::violations;
 
 /// S506
-pub fn unsafe_yaml_load(
-    func: &Expr,
-    args: &[Expr],
-    keywords: &[Keyword],
-    from_imports: &FxHashMap<&str, FxHashSet<&str>>,
-    import_aliases: &FxHashMap<&str, &str>,
-) -> Option<Diagnostic> {
-    if match_module_member(func, "yaml", "load", from_imports, import_aliases) {
+pub fn unsafe_yaml_load(checker: &mut Checker, func: &Expr, args: &[Expr], keywords: &[Keyword]) {
+    if checker
+        .resolve_call_path(func)
+        .map_or(false, |call_path| call_path == ["yaml", "load"])
+    {
         let call_args = SimpleCallArgs::new(args, keywords);
         if let Some(loader_arg) = call_args.get_argument("Loader", Some(1)) {
-            if !match_module_member(
-                loader_arg,
-                "yaml",
-                "SafeLoader",
-                from_imports,
-                import_aliases,
-            ) && !match_module_member(
-                loader_arg,
-                "yaml",
-                "CSafeLoader",
-                from_imports,
-                import_aliases,
-            ) {
+            if !checker
+                .resolve_call_path(loader_arg)
+                .map_or(false, |call_path| {
+                    call_path == ["yaml", "SafeLoader"] || call_path == ["yaml", "CSafeLoader"]
+                })
+            {
                 let loader = match &loader_arg.node {
                     ExprKind::Attribute { attr, .. } => Some(attr.to_string()),
                     ExprKind::Name { id, .. } => Some(id.to_string()),
                     _ => None,
                 };
-                return Some(Diagnostic::new(
+                checker.diagnostics.push(Diagnostic::new(
                     violations::UnsafeYAMLLoad(loader),
                     Range::from_located(loader_arg),
                 ));
             }
         } else {
-            return Some(Diagnostic::new(
+            checker.diagnostics.push(Diagnostic::new(
                 violations::UnsafeYAMLLoad(None),
                 Range::from_located(func),
             ));
         }
     }
-    None
 }

src/flake8_bandit/snapshots/ruff__flake8_bandit__tests__S701_S701.py.snap

@@ -0,0 +1,55 @@
+---
+source: src/flake8_bandit/mod.rs
+expression: diagnostics
+---
+- kind:
+    Jinja2AutoescapeFalse: true
+  location:
+    row: 9
+    column: 67
+  end_location:
+    row: 9
+    column: 76
+  fix: ~
+  parent: ~
+- kind:
+    Jinja2AutoescapeFalse: true
+  location:
+    row: 10
+    column: 44
+  end_location:
+    row: 10
+    column: 49
+  fix: ~
+  parent: ~
+- kind:
+    Jinja2AutoescapeFalse: true
+  location:
+    row: 13
+    column: 23
+  end_location:
+    row: 13
+    column: 28
+  fix: ~
+  parent: ~
+- kind:
+    Jinja2AutoescapeFalse: false
+  location:
+    row: 15
+    column: 0
+  end_location:
+    row: 15
+    column: 11
+  fix: ~
+  parent: ~
+- kind:
+    Jinja2AutoescapeFalse: true
+  location:
+    row: 29
+    column: 46
+  end_location:
+    row: 29
+    column: 57
+  fix: ~
+  parent: ~
+

src/flake8_blind_except/mod.rs

@@ -1,4 +1,4 @@
-pub mod rules;
+pub(crate) mod rules;
 
 #[cfg(test)]
 mod tests {

src/flake8_boolean_trap/mod.rs

@@ -1,4 +1,4 @@
-pub mod rules;
+pub(crate) mod rules;
 
 #[cfg(test)]
 mod tests {

src/flake8_bugbear/mod.rs

@@ -1,4 +1,4 @@
-pub mod rules;
+pub(crate) mod rules;
 pub mod settings;
 
 #[cfg(test)]
@@ -8,9 +8,10 @@ mod tests {
     use anyhow::Result;
     use test_case::test_case;
 
+    use crate::flake8_bugbear;
     use crate::linter::test_path;
     use crate::registry::RuleCode;
-    use crate::{flake8_bugbear, Settings};
+    use crate::settings::Settings;
 
     #[test_case(RuleCode::B002, Path::new("B002.py"); "B002")]
     #[test_case(RuleCode::B003, Path::new("B003.py"); "B003")]

src/flake8_bugbear/rules/abstract_base_class.rs

@@ -1,34 +1,26 @@
-use rustc_hash::{FxHashMap, FxHashSet};
 use rustpython_ast::{Constant, Expr, ExprKind, Keyword, Stmt, StmtKind};
 
-use crate::ast::helpers::match_module_member;
 use crate::ast::types::Range;
 use crate::checkers::ast::Checker;
 use crate::registry::{Diagnostic, RuleCode};
 use crate::violations;
+use crate::visibility::{is_abstract, is_overload};
 
-fn is_abc_class(
-    bases: &[Expr],
-    keywords: &[Keyword],
-    from_imports: &FxHashMap<&str, FxHashSet<&str>>,
-    import_aliases: &FxHashMap<&str, &str>,
-) -> bool {
+fn is_abc_class(checker: &Checker, bases: &[Expr], keywords: &[Keyword]) -> bool {
     keywords.iter().any(|keyword| {
         keyword
             .node
             .arg
             .as_ref()
-            .map_or(false, |a| a == "metaclass")
-            && match_module_member(
-                &keyword.node.value,
-                "abc",
-                "ABCMeta",
-                from_imports,
-                import_aliases,
-            )
-    }) || bases
-        .iter()
-        .any(|base| match_module_member(base, "abc", "ABC", from_imports, import_aliases))
+            .map_or(false, |arg| arg == "metaclass")
+            && checker
+                .resolve_call_path(&keyword.node.value)
+                .map_or(false, |call_path| call_path == ["abc", "ABCMeta"])
+    }) || bases.iter().any(|base| {
+        checker
+            .resolve_call_path(base)
+            .map_or(false, |call_path| call_path == ["abc", "ABC"])
+    })
 }
 
 fn is_empty_body(body: &[Stmt]) -> bool {
@@ -44,22 +36,6 @@ fn is_empty_body(body: &[Stmt]) -> bool {
     })
 }
 
-fn is_abstractmethod(
-    expr: &Expr,
-    from_imports: &FxHashMap<&str, FxHashSet<&str>>,
-    import_aliases: &FxHashMap<&str, &str>,
-) -> bool {
-    match_module_member(expr, "abc", "abstractmethod", from_imports, import_aliases)
-}
-
-fn is_overload(
-    expr: &Expr,
-    from_imports: &FxHashMap<&str, FxHashSet<&str>>,
-    import_aliases: &FxHashMap<&str, &str>,
-) -> bool {
-    match_module_member(expr, "typing", "overload", from_imports, import_aliases)
-}
-
 pub fn abstract_base_class(
     checker: &mut Checker,
     stmt: &Stmt,
@@ -71,12 +47,7 @@ pub fn abstract_base_class(
     if bases.len() + keywords.len() != 1 {
         return;
     }
-    if !is_abc_class(
-        bases,
-        keywords,
-        &checker.from_imports,
-        &checker.import_aliases,
-    ) {
+    if !is_abc_class(checker, bases, keywords) {
         return;
     }
 
@@ -102,22 +73,14 @@ pub fn abstract_base_class(
             continue;
         };
 
-        let has_abstract_decorator = decorator_list
-            .iter()
-            .any(|d| is_abstractmethod(d, &checker.from_imports, &checker.import_aliases));
-
+        let has_abstract_decorator = is_abstract(checker, decorator_list);
         has_abstract_method |= has_abstract_decorator;
 
         if !checker.settings.enabled.contains(&RuleCode::B027) {
             continue;
         }
 
-        if !has_abstract_decorator
-            && is_empty_body(body)
-            && !decorator_list
-                .iter()
-                .any(|d| is_overload(d, &checker.from_imports, &checker.import_aliases))
-        {
+        if !has_abstract_decorator && is_empty_body(body) && !is_overload(checker, decorator_list) {
             checker.diagnostics.push(Diagnostic::new(
                 violations::EmptyMethodWithoutAbstractDecorator(name.to_string()),
                 Range::from_located(stmt),

src/flake8_bugbear/rules/assert_false.rs

@@ -1,10 +1,10 @@
 use rustpython_ast::{Constant, Expr, ExprContext, ExprKind, Location, Stmt, StmtKind};
 
 use crate::ast::types::Range;
-use crate::autofix::Fix;
 use crate::checkers::ast::Checker;
+use crate::fix::Fix;
 use crate::registry::Diagnostic;
-use crate::source_code_generator::SourceCodeGenerator;
+use crate::source_code::Generator;
 use crate::violations;
 
 fn assertion_error(msg: Option<&Expr>) -> Stmt {
@@ -48,7 +48,7 @@ pub fn assert_false(checker: &mut Checker, stmt: &Stmt, test: &Expr, msg: Option
 
     let mut diagnostic = Diagnostic::new(violations::DoNotAssertFalse, Range::from_located(test));
     if checker.patch(diagnostic.kind.code()) {
-        let mut generator: SourceCodeGenerator = checker.style.into();
+        let mut generator: Generator = checker.style.into();
         generator.unparse_stmt(&assertion_error(msg));
         diagnostic.amend(Fix::replacement(
             generator.generate(),

src/flake8_bugbear/rules/assert_raises_exception.rs

@@ -1,6 +1,5 @@
 use rustpython_ast::{ExprKind, Stmt, Withitem};
 
-use crate::ast::helpers::match_module_member;
 use crate::ast::types::Range;
 use crate::checkers::ast::Checker;
 use crate::registry::Diagnostic;
@@ -24,13 +23,10 @@ pub fn assert_raises_exception(checker: &mut Checker, stmt: &Stmt, items: &[With
     if !matches!(&func.node, ExprKind::Attribute { attr, .. } if attr == "assertRaises") {
         return;
     }
-    if !match_module_member(
-        args.first().unwrap(),
-        "",
-        "Exception",
-        &checker.from_imports,
-        &checker.import_aliases,
-    ) {
+    if !checker
+        .resolve_call_path(args.first().unwrap())
+        .map_or(false, |call_path| call_path == ["", "Exception"])
+    {
         return;
     }
 

src/flake8_bugbear/rules/cached_instance_method.rs

@@ -1,15 +1,14 @@
 use rustpython_ast::{Expr, ExprKind};
 
-use crate::ast::helpers::{collect_call_paths, dealias_call_path, match_call_path};
 use crate::ast::types::{Range, ScopeKind};
 use crate::checkers::ast::Checker;
 use crate::registry::Diagnostic;
 use crate::violations;
 
 fn is_cache_func(checker: &Checker, expr: &Expr) -> bool {
-    let call_path = dealias_call_path(collect_call_paths(expr), &checker.import_aliases);
-    match_call_path(&call_path, "functools", "lru_cache", &checker.from_imports)
-        || match_call_path(&call_path, "functools", "cache", &checker.from_imports)
+    checker.resolve_call_path(expr).map_or(false, |call_path| {
+        call_path == ["functools", "lru_cache"] || call_path == ["functools", "cache"]
+    })
 }
 
 /// B019

src/flake8_bugbear/rules/duplicate_exceptions.rs

@@ -4,10 +4,10 @@ use rustpython_ast::{Excepthandler, ExcepthandlerKind, Expr, ExprContext, ExprKi
 
 use crate::ast::helpers;
 use crate::ast::types::Range;
-use crate::autofix::Fix;
 use crate::checkers::ast::Checker;
+use crate::fix::Fix;
 use crate::registry::{Diagnostic, RuleCode};
-use crate::source_code_generator::SourceCodeGenerator;
+use crate::source_code::Generator;
 use crate::violations;
 
 fn type_pattern(elts: Vec<&Expr>) -> Expr {
@@ -30,7 +30,7 @@ fn duplicate_handler_exceptions<'a>(
     let mut duplicates: FxHashSet<Vec<&str>> = FxHashSet::default();
     let mut unique_elts: Vec<&Expr> = Vec::default();
     for type_ in elts {
-        let call_path = helpers::collect_call_paths(type_);
+        let call_path = helpers::collect_call_path(type_);
         if !call_path.is_empty() {
             if seen.contains_key(&call_path) {
                 duplicates.insert(call_path);
@@ -55,7 +55,7 @@ fn duplicate_handler_exceptions<'a>(
                 Range::from_located(expr),
             );
             if checker.patch(diagnostic.kind.code()) {
-                let mut generator: SourceCodeGenerator = checker.style.into();
+                let mut generator: Generator = checker.style.into();
                 if unique_elts.len() == 1 {
                     generator.unparse_expr(unique_elts[0], 0);
                 } else {
@@ -83,7 +83,7 @@ pub fn duplicate_exceptions(checker: &mut Checker, handlers: &[Excepthandler]) {
         };
         match &type_.node {
             ExprKind::Attribute { .. } | ExprKind::Name { .. } => {
-                let call_path = helpers::collect_call_paths(type_);
+                let call_path = helpers::collect_call_path(type_);
                 if !call_path.is_empty() {
                     if seen.contains(&call_path) {
                         duplicates.entry(call_path).or_default().push(type_);

src/flake8_bugbear/rules/function_call_argument_default.rs

@@ -1,9 +1,6 @@
-use rustc_hash::{FxHashMap, FxHashSet};
 use rustpython_ast::{Arguments, Constant, Expr, ExprKind};
 
-use crate::ast::helpers::{
-    collect_call_paths, compose_call_path, dealias_call_path, match_call_path, to_module_and_member,
-};
+use crate::ast::helpers::{compose_call_path, to_call_path};
 use crate::ast::types::Range;
 use crate::ast::visitor;
 use crate::ast::visitor::Visitor;
@@ -12,34 +9,29 @@ use crate::flake8_bugbear::rules::mutable_argument_default::is_mutable_func;
 use crate::registry::{Diagnostic, DiagnosticKind};
 use crate::violations;
 
-const IMMUTABLE_FUNCS: [(&str, &str); 7] = [
-    ("", "tuple"),
-    ("", "frozenset"),
-    ("operator", "attrgetter"),
-    ("operator", "itemgetter"),
-    ("operator", "methodcaller"),
-    ("types", "MappingProxyType"),
-    ("re", "compile"),
+const IMMUTABLE_FUNCS: &[&[&str]] = &[
+    &["", "tuple"],
+    &["", "frozenset"],
+    &["operator", "attrgetter"],
+    &["operator", "itemgetter"],
+    &["operator", "methodcaller"],
+    &["types", "MappingProxyType"],
+    &["re", "compile"],
 ];
 
-fn is_immutable_func(
-    expr: &Expr,
-    extend_immutable_calls: &[(&str, &str)],
-    from_imports: &FxHashMap<&str, FxHashSet<&str>>,
-    import_aliases: &FxHashMap<&str, &str>,
-) -> bool {
-    let call_path = dealias_call_path(collect_call_paths(expr), import_aliases);
-    IMMUTABLE_FUNCS
-        .iter()
-        .chain(extend_immutable_calls)
-        .any(|(module, member)| match_call_path(&call_path, module, member, from_imports))
+fn is_immutable_func(checker: &Checker, expr: &Expr, extend_immutable_calls: &[Vec<&str>]) -> bool {
+    checker.resolve_call_path(expr).map_or(false, |call_path| {
+        IMMUTABLE_FUNCS.iter().any(|target| call_path == *target)
+            || extend_immutable_calls
+                .iter()
+                .any(|target| call_path == *target)
+    })
 }
 
 struct ArgumentDefaultVisitor<'a> {
+    checker: &'a Checker<'a>,
     diagnostics: Vec<(DiagnosticKind, Range)>,
-    extend_immutable_calls: &'a [(&'a str, &'a str)],
-    from_imports: &'a FxHashMap<&'a str, FxHashSet<&'a str>>,
-    import_aliases: &'a FxHashMap<&'a str, &'a str>,
+    extend_immutable_calls: Vec<Vec<&'a str>>,
 }
 
 impl<'a, 'b> Visitor<'b> for ArgumentDefaultVisitor<'b>
@@ -49,13 +41,8 @@ where
     fn visit_expr(&mut self, expr: &'b Expr) {
         match &expr.node {
             ExprKind::Call { func, args, .. } => {
-                if !is_mutable_func(func, self.from_imports, self.import_aliases)
-                    && !is_immutable_func(
-                        func,
-                        self.extend_immutable_calls,
-                        self.from_imports,
-                        self.import_aliases,
-                    )
+                if !is_mutable_func(self.checker, func)
+                    && !is_immutable_func(self.checker, func, &self.extend_immutable_calls)
                     && !is_nan_or_infinity(func, args)
                 {
                     self.diagnostics.push((
@@ -97,27 +84,29 @@ fn is_nan_or_infinity(expr: &Expr, args: &[Expr]) -> bool {
 /// B008
 pub fn function_call_argument_default(checker: &mut Checker, arguments: &Arguments) {
     // Map immutable calls to (module, member) format.
-    let extend_immutable_cells: Vec<(&str, &str)> = checker
+    let extend_immutable_calls: Vec<Vec<&str>> = checker
         .settings
         .flake8_bugbear
         .extend_immutable_calls
         .iter()
-        .map(|target| to_module_and_member(target))
+        .map(|target| to_call_path(target))
         .collect();
-    let mut visitor = ArgumentDefaultVisitor {
-        diagnostics: vec![],
-        extend_immutable_calls: &extend_immutable_cells,
-        from_imports: &checker.from_imports,
-        import_aliases: &checker.import_aliases,
+    let diagnostics = {
+        let mut visitor = ArgumentDefaultVisitor {
+            checker,
+            diagnostics: vec![],
+            extend_immutable_calls,
+        };
+        for expr in arguments
+            .defaults
+            .iter()
+            .chain(arguments.kw_defaults.iter())
+        {
+            visitor.visit_expr(expr);
+        }
+        visitor.diagnostics
     };
-    for expr in arguments
-        .defaults
-        .iter()
-        .chain(arguments.kw_defaults.iter())
-    {
-        visitor.visit_expr(expr);
-    }
-    for (check, range) in visitor.diagnostics {
+    for (check, range) in diagnostics {
         checker.diagnostics.push(Diagnostic::new(check, range));
     }
 }

src/flake8_bugbear/rules/getattr_with_constant.rs

@@ -1,12 +1,12 @@
 use rustpython_ast::{Constant, Expr, ExprContext, ExprKind, Location};
 
 use crate::ast::types::Range;
-use crate::autofix::Fix;
 use crate::checkers::ast::Checker;
+use crate::fix::Fix;
 use crate::python::identifiers::IDENTIFIER_REGEX;
 use crate::python::keyword::KWLIST;
 use crate::registry::Diagnostic;
-use crate::source_code_generator::SourceCodeGenerator;
+use crate::source_code::Generator;
 use crate::violations;
 
 fn attribute(value: &Expr, attr: &str) -> Expr {
@@ -48,7 +48,7 @@ pub fn getattr_with_constant(checker: &mut Checker, expr: &Expr, func: &Expr, ar
     let mut diagnostic =
         Diagnostic::new(violations::GetAttrWithConstant, Range::from_located(expr));
     if checker.patch(diagnostic.kind.code()) {
-        let mut generator: SourceCodeGenerator = checker.style.into();
+        let mut generator: Generator = checker.style.into();
         generator.unparse_expr(&attribute(obj, value), 0);
         diagnostic.amend(Fix::replacement(
             generator.generate(),

src/flake8_bugbear/rules/mutable_argument_default.rs

@@ -1,79 +1,68 @@
-use rustc_hash::{FxHashMap, FxHashSet};
 use rustpython_ast::{Arguments, Constant, Expr, ExprKind, Operator};
 
-use crate::ast::helpers::{collect_call_paths, dealias_call_path, match_call_path};
 use crate::ast::types::Range;
 use crate::checkers::ast::Checker;
 use crate::registry::Diagnostic;
 use crate::violations;
 
-const MUTABLE_FUNCS: &[(&str, &str)] = &[
-    ("", "dict"),
-    ("", "list"),
-    ("", "set"),
-    ("collections", "Counter"),
-    ("collections", "OrderedDict"),
-    ("collections", "defaultdict"),
-    ("collections", "deque"),
+const MUTABLE_FUNCS: &[&[&str]] = &[
+    &["", "dict"],
+    &["", "list"],
+    &["", "set"],
+    &["collections", "Counter"],
+    &["collections", "OrderedDict"],
+    &["collections", "defaultdict"],
+    &["collections", "deque"],
 ];
 
-const IMMUTABLE_TYPES: &[(&str, &str)] = &[
-    ("", "bool"),
-    ("", "bytes"),
-    ("", "complex"),
-    ("", "float"),
-    ("", "frozenset"),
-    ("", "int"),
-    ("", "object"),
-    ("", "range"),
-    ("", "str"),
-    ("collections.abc", "Sized"),
-    ("typing", "LiteralString"),
-    ("typing", "Sized"),
+const IMMUTABLE_TYPES: &[&[&str]] = &[
+    &["", "bool"],
+    &["", "bytes"],
+    &["", "complex"],
+    &["", "float"],
+    &["", "frozenset"],
+    &["", "int"],
+    &["", "object"],
+    &["", "range"],
+    &["", "str"],
+    &["collections", "abc", "Sized"],
+    &["typing", "LiteralString"],
+    &["typing", "Sized"],
 ];
 
-const IMMUTABLE_GENERIC_TYPES: &[(&str, &str)] = &[
-    ("", "tuple"),
-    ("collections.abc", "ByteString"),
-    ("collections.abc", "Collection"),
-    ("collections.abc", "Container"),
-    ("collections.abc", "Iterable"),
-    ("collections.abc", "Mapping"),
-    ("collections.abc", "Reversible"),
-    ("collections.abc", "Sequence"),
-    ("collections.abc", "Set"),
-    ("typing", "AbstractSet"),
-    ("typing", "ByteString"),
-    ("typing", "Callable"),
-    ("typing", "Collection"),
-    ("typing", "Container"),
-    ("typing", "FrozenSet"),
-    ("typing", "Iterable"),
-    ("typing", "Literal"),
-    ("typing", "Mapping"),
-    ("typing", "Never"),
-    ("typing", "NoReturn"),
-    ("typing", "Reversible"),
-    ("typing", "Sequence"),
-    ("typing", "Tuple"),
+const IMMUTABLE_GENERIC_TYPES: &[&[&str]] = &[
+    &["", "tuple"],
+    &["collections", "abc", "ByteString"],
+    &["collections", "abc", "Collection"],
+    &["collections", "abc", "Container"],
+    &["collections", "abc", "Iterable"],
+    &["collections", "abc", "Mapping"],
+    &["collections", "abc", "Reversible"],
+    &["collections", "abc", "Sequence"],
+    &["collections", "abc", "Set"],
+    &["typing", "AbstractSet"],
+    &["typing", "ByteString"],
+    &["typing", "Callable"],
+    &["typing", "Collection"],
+    &["typing", "Container"],
+    &["typing", "FrozenSet"],
+    &["typing", "Iterable"],
+    &["typing", "Literal"],
+    &["typing", "Mapping"],
+    &["typing", "Never"],
+    &["typing", "NoReturn"],
+    &["typing", "Reversible"],
+    &["typing", "Sequence"],
+    &["typing", "Tuple"],
 ];
 
-pub fn is_mutable_func(
-    expr: &Expr,
-    from_imports: &FxHashMap<&str, FxHashSet<&str>>,
-    import_aliases: &FxHashMap<&str, &str>,
-) -> bool {
-    let call_path = dealias_call_path(collect_call_paths(expr), import_aliases);
-    MUTABLE_FUNCS
-        .iter()
-        .any(|(module, member)| match_call_path(&call_path, module, member, from_imports))
+pub fn is_mutable_func(checker: &Checker, expr: &Expr) -> bool {
+    checker.resolve_call_path(expr).map_or(false, |call_path| {
+        MUTABLE_FUNCS.iter().any(|target| call_path == *target)
+    })
 }
 
-fn is_mutable_expr(
-    expr: &Expr,
-    from_imports: &FxHashMap<&str, FxHashSet<&str>>,
-    import_aliases: &FxHashMap<&str, &str>,
-) -> bool {
+fn is_mutable_expr(checker: &Checker, expr: &Expr) -> bool {
     match &expr.node {
         ExprKind::List { .. }
         | ExprKind::Dict { .. }
@@ -81,60 +70,53 @@ fn is_mutable_expr(
         | ExprKind::ListComp { .. }
         | ExprKind::DictComp { .. }
         | ExprKind::SetComp { .. } => true,
-        ExprKind::Call { func, .. } => is_mutable_func(func, from_imports, import_aliases),
+        ExprKind::Call { func, .. } => is_mutable_func(checker, func),
         _ => false,
     }
 }
 
-fn is_immutable_annotation(
-    expr: &Expr,
-    from_imports: &FxHashMap<&str, FxHashSet<&str>>,
-    import_aliases: &FxHashMap<&str, &str>,
-) -> bool {
+fn is_immutable_annotation(checker: &Checker, expr: &Expr) -> bool {
     match &expr.node {
         ExprKind::Name { .. } | ExprKind::Attribute { .. } => {
-            let call_path = dealias_call_path(collect_call_paths(expr), import_aliases);
-            IMMUTABLE_TYPES
-                .iter()
-                .chain(IMMUTABLE_GENERIC_TYPES)
-                .any(|(module, member)| match_call_path(&call_path, module, member, from_imports))
+            checker.resolve_call_path(expr).map_or(false, |call_path| {
+                IMMUTABLE_TYPES
+                    .iter()
+                    .chain(IMMUTABLE_GENERIC_TYPES)
+                    .any(|target| call_path == *target)
+            })
         }
         ExprKind::Subscript { value, slice, .. } => {
-            let call_path = dealias_call_path(collect_call_paths(value), import_aliases);
-            if IMMUTABLE_GENERIC_TYPES
-                .iter()
-                .any(|(module, member)| match_call_path(&call_path, module, member, from_imports))
-            {
-                true
-            } else if match_call_path(&call_path, "typing", "Union", from_imports) {
-                if let ExprKind::Tuple { elts, .. } = &slice.node {
-                    elts.iter()
-                        .all(|elt| is_immutable_annotation(elt, from_imports, import_aliases))
+            checker.resolve_call_path(value).map_or(false, |call_path| {
+                if IMMUTABLE_GENERIC_TYPES
+                    .iter()
+                    .any(|target| call_path == *target)
+                {
+                    true
+                } else if call_path == ["typing", "Union"] {
+                    if let ExprKind::Tuple { elts, .. } = &slice.node {
+                        elts.iter().all(|elt| is_immutable_annotation(checker, elt))
+                    } else {
+                        false
+                    }
+                } else if call_path == ["typing", "Optional"] {
+                    is_immutable_annotation(checker, slice)
+                } else if call_path == ["typing", "Annotated"] {
+                    if let ExprKind::Tuple { elts, .. } = &slice.node {
+                        elts.first()
+                            .map_or(false, |elt| is_immutable_annotation(checker, elt))
+                    } else {
+                        false
+                    }
                 } else {
                     false
                 }
-            } else if match_call_path(&call_path, "typing", "Optional", from_imports) {
-                is_immutable_annotation(slice, from_imports, import_aliases)
-            } else if match_call_path(&call_path, "typing", "Annotated", from_imports) {
-                if let ExprKind::Tuple { elts, .. } = &slice.node {
-                    elts.first().map_or(false, |elt| {
-                        is_immutable_annotation(elt, from_imports, import_aliases)
-                    })
-                } else {
-                    false
-                }
-            } else {
-                false
-            }
+            })
         }
         ExprKind::BinOp {
             left,
             op: Operator::BitOr,
             right,
-        } => {
-            is_immutable_annotation(left, from_imports, import_aliases)
-                && is_immutable_annotation(right, from_imports, import_aliases)
-        }
+        } => is_immutable_annotation(checker, left) && is_immutable_annotation(checker, right),
         ExprKind::Constant {
             value: Constant::None,
             ..
@@ -145,7 +127,7 @@ fn is_immutable_annotation(
 
 /// B006
 pub fn mutable_argument_default(checker: &mut Checker, arguments: &Arguments) {
-    // Scan in reverse order to right-align zip()
+    // Scan in reverse order to right-align zip().
     for (arg, default) in arguments
         .kwonlyargs
         .iter()
@@ -160,10 +142,12 @@ pub fn mutable_argument_default(checker: &mut Checker, arguments: &Arguments) {
                 .zip(arguments.defaults.iter().rev()),
         )
     {
-        if is_mutable_expr(default, &checker.from_imports, &checker.import_aliases)
-            && arg.node.annotation.as_ref().map_or(true, |expr| {
-                !is_immutable_annotation(expr, &checker.from_imports, &checker.import_aliases)
-            })
+        if is_mutable_expr(checker, default)
+            && !arg
+                .node
+                .annotation
+                .as_ref()
+                .map_or(false, |expr| is_immutable_annotation(checker, expr))
         {
             checker.diagnostics.push(Diagnostic::new(
                 violations::MutableArgumentDefault,

src/flake8_bugbear/rules/redundant_tuple_in_exception_handler.rs

@@ -1,10 +1,10 @@
 use rustpython_ast::{Excepthandler, ExcepthandlerKind, ExprKind};
 
 use crate::ast::types::Range;
-use crate::autofix::Fix;
 use crate::checkers::ast::Checker;
+use crate::fix::Fix;
 use crate::registry::Diagnostic;
-use crate::source_code_generator::SourceCodeGenerator;
+use crate::source_code::Generator;
 use crate::violations;
 
 /// B013
@@ -24,7 +24,7 @@ pub fn redundant_tuple_in_exception_handler(checker: &mut Checker, handlers: &[E
             Range::from_located(type_),
         );
         if checker.patch(diagnostic.kind.code()) {
-            let mut generator: SourceCodeGenerator = checker.style.into();
+            let mut generator: Generator = checker.style.into();
             generator.unparse_expr(elt, 0);
             diagnostic.amend(Fix::replacement(
                 generator.generate(),

src/flake8_bugbear/rules/setattr_with_constant.rs

@@ -1,16 +1,15 @@
 use rustpython_ast::{Constant, Expr, ExprContext, ExprKind, Location, Stmt, StmtKind};
 
 use crate::ast::types::Range;
-use crate::autofix::Fix;
 use crate::checkers::ast::Checker;
+use crate::fix::Fix;
 use crate::python::identifiers::IDENTIFIER_REGEX;
 use crate::python::keyword::KWLIST;
 use crate::registry::Diagnostic;
-use crate::source_code_generator::SourceCodeGenerator;
-use crate::source_code_style::SourceCodeStyleDetector;
+use crate::source_code::{Generator, Stylist};
 use crate::violations;
 
-fn assignment(obj: &Expr, name: &str, value: &Expr, stylist: &SourceCodeStyleDetector) -> String {
+fn assignment(obj: &Expr, name: &str, value: &Expr, stylist: &Stylist) -> String {
     let stmt = Stmt::new(
         Location::default(),
         Location::default(),
@@ -28,7 +27,7 @@ fn assignment(obj: &Expr, name: &str, value: &Expr, stylist: &SourceCodeStyleDet
             type_comment: None,
         },
     );
-    let mut generator: SourceCodeGenerator = stylist.into();
+    let mut generator: Generator = stylist.into();
     generator.unparse_stmt(&stmt);
     generator.generate()
 }

src/flake8_bugbear/rules/unused_loop_control_variable.rs

@@ -4,8 +4,8 @@ use rustpython_ast::{Expr, ExprKind, Stmt};
 use crate::ast::types::Range;
 use crate::ast::visitor;
 use crate::ast::visitor::Visitor;
-use crate::autofix::Fix;
 use crate::checkers::ast::Checker;
+use crate::fix::Fix;
 use crate::registry::Diagnostic;
 use crate::violations;
 

src/flake8_bugbear/rules/useless_contextlib_suppress.rs

@@ -1,6 +1,5 @@
 use rustpython_ast::Expr;
 
-use crate::ast::helpers::{collect_call_paths, match_call_path};
 use crate::ast::types::Range;
 use crate::checkers::ast::Checker;
 use crate::registry::Diagnostic;
@@ -8,12 +7,10 @@ use crate::violations;
 
 /// B005
 pub fn useless_contextlib_suppress(checker: &mut Checker, expr: &Expr, args: &[Expr]) {
-    if match_call_path(
-        &collect_call_paths(expr),
-        "contextlib",
-        "suppress",
-        &checker.from_imports,
-    ) && args.is_empty()
+    if args.is_empty()
+        && checker
+            .resolve_call_path(expr)
+            .map_or(false, |call_path| call_path == ["contextlib", "suppress"])
     {
         checker.diagnostics.push(Diagnostic::new(
             violations::UselessContextlibSuppress,

src/flake8_bugbear/snapshots/ruff__flake8_bugbear__tests__B024_B024.py.snap

@@ -1,64 +1,64 @@
 ---
 source: src/flake8_bugbear/mod.rs
-expression: checks
+expression: diagnostics
 ---
 - kind:
     AbstractBaseClassWithoutAbstractMethod: Base_1
   location:
-    row: 17
+    row: 18
     column: 0
   end_location:
-    row: 19
+    row: 20
     column: 13
   fix: ~
   parent: ~
 - kind:
     AbstractBaseClassWithoutAbstractMethod: MetaBase_1
   location:
-    row: 58
+    row: 71
     column: 0
   end_location:
-    row: 60
+    row: 73
     column: 13
   fix: ~
   parent: ~
 - kind:
     AbstractBaseClassWithoutAbstractMethod: abc_Base_1
   location:
-    row: 69
+    row: 82
     column: 0
   end_location:
-    row: 71
+    row: 84
     column: 13
   fix: ~
   parent: ~
 - kind:
     AbstractBaseClassWithoutAbstractMethod: abc_Base_2
   location:
-    row: 74
+    row: 87
     column: 0
   end_location:
-    row: 76
+    row: 89
     column: 13
   fix: ~
   parent: ~
 - kind:
     AbstractBaseClassWithoutAbstractMethod: notabc_Base_1
   location:
-    row: 79
+    row: 92
     column: 0
   end_location:
-    row: 81
+    row: 94
     column: 13
   fix: ~
   parent: ~
 - kind:
     AbstractBaseClassWithoutAbstractMethod: abc_set_class_variable_4
   location:
-    row: 128
+    row: 141
     column: 0
   end_location:
-    row: 129
+    row: 142
     column: 7
   fix: ~
   parent: ~

src/flake8_bugbear/snapshots/ruff__flake8_bugbear__tests__B027_B027.py.snap

@@ -1,44 +1,44 @@
 ---
 source: src/flake8_bugbear/mod.rs
-expression: checks
+expression: diagnostics
 ---
 - kind:
     EmptyMethodWithoutAbstractDecorator: AbstractClass
   location:
-    row: 12
+    row: 13
     column: 4
   end_location:
-    row: 13
+    row: 14
     column: 11
   fix: ~
   parent: ~
 - kind:
     EmptyMethodWithoutAbstractDecorator: AbstractClass
   location:
-    row: 15
+    row: 16
     column: 4
   end_location:
-    row: 16
+    row: 17
     column: 12
   fix: ~
   parent: ~
 - kind:
     EmptyMethodWithoutAbstractDecorator: AbstractClass
   location:
-    row: 18
+    row: 19
     column: 4
   end_location:
-    row: 20
+    row: 21
     column: 11
   fix: ~
   parent: ~
 - kind:
     EmptyMethodWithoutAbstractDecorator: AbstractClass
   location:
-    row: 22
+    row: 23
     column: 4
   end_location:
-    row: 27
+    row: 28
     column: 12
   fix: ~
   parent: ~

src/flake8_builtins/mod.rs

@@ -1,5 +1,5 @@
-pub mod rules;
-pub mod types;
+pub(crate) mod rules;
+pub(crate) mod types;
 
 #[cfg(test)]
 mod tests {

src/flake8_comprehensions/fixes.rs

@@ -7,9 +7,9 @@ use libcst_native::{
 };
 
 use crate::ast::types::Range;
-use crate::autofix::Fix;
 use crate::cst::matchers::{match_expr, match_module};
-use crate::source_code_locator::SourceCodeLocator;
+use crate::fix::Fix;
+use crate::source_code::Locator;
 
 fn match_call<'a, 'b>(expr: &'a mut Expr<'b>) -> Result<&'a mut Call<'b>> {
     if let Expression::Call(call) = &mut expr.value {
@@ -29,7 +29,7 @@ fn match_arg<'a, 'b>(call: &'a Call<'b>) -> Result<&'a Arg<'b>> {
 
 /// (C400) Convert `list(x for x in y)` to `[x for x in y]`.
 pub fn fix_unnecessary_generator_list(
-    locator: &SourceCodeLocator,
+    locator: &Locator,
     expr: &rustpython_ast::Expr,
 ) -> Result<Fix> {
     // Expr(Call(GeneratorExp)))) -> Expr(ListComp)))
@@ -70,7 +70,7 @@ pub fn fix_unnecessary_generator_list(
 
 /// (C401) Convert `set(x for x in y)` to `{x for x in y}`.
 pub fn fix_unnecessary_generator_set(
-    locator: &SourceCodeLocator,
+    locator: &Locator,
     expr: &rustpython_ast::Expr,
 ) -> Result<Fix> {
     // Expr(Call(GeneratorExp)))) -> Expr(SetComp)))
@@ -112,7 +112,7 @@ pub fn fix_unnecessary_generator_set(
 /// (C402) Convert `dict((x, x) for x in range(3))` to `{x: x for x in
 /// range(3)}`.
 pub fn fix_unnecessary_generator_dict(
-    locator: &SourceCodeLocator,
+    locator: &Locator,
     expr: &rustpython_ast::Expr,
 ) -> Result<Fix> {
     let module_text = locator.slice_source_code_range(&Range::from_located(expr));
@@ -169,7 +169,7 @@ pub fn fix_unnecessary_generator_dict(
 
 /// (C403) Convert `set([x for x in y])` to `{x for x in y}`.
 pub fn fix_unnecessary_list_comprehension_set(
-    locator: &SourceCodeLocator,
+    locator: &Locator,
     expr: &rustpython_ast::Expr,
 ) -> Result<Fix> {
     // Expr(Call(ListComp)))) ->
@@ -210,7 +210,7 @@ pub fn fix_unnecessary_list_comprehension_set(
 /// (C404) Convert `dict([(i, i) for i in range(3)])` to `{i: i for i in
 /// range(3)}`.
 pub fn fix_unnecessary_list_comprehension_dict(
-    locator: &SourceCodeLocator,
+    locator: &Locator,
     expr: &rustpython_ast::Expr,
 ) -> Result<Fix> {
     let module_text = locator.slice_source_code_range(&Range::from_located(expr));
@@ -258,11 +258,51 @@ pub fn fix_unnecessary_list_comprehension_dict(
     ))
 }
 
+/// Drop a trailing comma from a list of tuple elements.
+fn drop_trailing_comma<'a>(
+    tuple: &Tuple<'a>,
+) -> Result<(
+    Vec<Element<'a>>,
+    ParenthesizableWhitespace<'a>,
+    ParenthesizableWhitespace<'a>,
+)> {
+    let whitespace_after = tuple
+        .lpar
+        .first()
+        .ok_or_else(|| anyhow::anyhow!("Expected at least one set of parentheses"))?
+        .whitespace_after
+        .clone();
+    let whitespace_before = tuple
+        .rpar
+        .first()
+        .ok_or_else(|| anyhow::anyhow!("Expected at least one set of parentheses"))?
+        .whitespace_before
+        .clone();
+
+    let mut elements = tuple.elements.clone();
+    if elements.len() == 1 {
+        if let Some(Element::Simple {
+            value,
+            comma: Some(..),
+            ..
+        }) = elements.last()
+        {
+            if whitespace_before == ParenthesizableWhitespace::default()
+                && whitespace_after == ParenthesizableWhitespace::default()
+            {
+                elements[0] = Element::Simple {
+                    value: value.clone(),
+                    comma: None,
+                };
+            }
+        }
+    }
+
+    Ok((elements, whitespace_after, whitespace_before))
+}
+
 /// (C405) Convert `set((1, 2))` to `{1, 2}`.
-pub fn fix_unnecessary_literal_set(
-    locator: &SourceCodeLocator,
-    expr: &rustpython_ast::Expr,
-) -> Result<Fix> {
+pub fn fix_unnecessary_literal_set(locator: &Locator, expr: &rustpython_ast::Expr) -> Result<Fix> {
     // Expr(Call(List|Tuple)))) -> Expr(Set)))
     let module_text = locator.slice_source_code_range(&Range::from_located(expr));
     let mut tree = match_module(&module_text)?;
@@ -270,9 +310,13 @@ pub fn fix_unnecessary_literal_set(
     let mut call = match_call(body)?;
     let arg = match_arg(call)?;
 
-    let elements = match &arg.value {
-        Expression::Tuple(inner) => &inner.elements,
-        Expression::List(inner) => &inner.elements,
+    let (elements, whitespace_after, whitespace_before) = match &arg.value {
+        Expression::Tuple(inner) => drop_trailing_comma(inner)?,
+        Expression::List(inner) => (
+            inner.elements.clone(),
+            inner.lbracket.whitespace_after.clone(),
+            inner.rbracket.whitespace_before.clone(),
+        ),
         _ => {
             bail!("Expected Expression::Tuple | Expression::List");
         }
@@ -282,13 +326,9 @@ pub fn fix_unnecessary_literal_set(
         call.args = vec![];
     } else {
         body.value = Expression::Set(Box::new(Set {
-            elements: elements.clone(),
-            lbrace: LeftCurlyBrace {
-                whitespace_after: call.whitespace_before_args.clone(),
-            },
-            rbrace: RightCurlyBrace {
-                whitespace_before: arg.whitespace_after_arg.clone(),
-            },
+            elements,
+            lbrace: LeftCurlyBrace { whitespace_after },
+            rbrace: RightCurlyBrace { whitespace_before },
             lpar: vec![],
             rpar: vec![],
         }));
@@ -305,10 +345,7 @@ pub fn fix_unnecessary_literal_set(
 }
 
 /// (C406) Convert `dict([(1, 2)])` to `{1: 2}`.
-pub fn fix_unnecessary_literal_dict(
-    locator: &SourceCodeLocator,
-    expr: &rustpython_ast::Expr,
-) -> Result<Fix> {
+pub fn fix_unnecessary_literal_dict(locator: &Locator, expr: &rustpython_ast::Expr) -> Result<Fix> {
     // Expr(Call(List|Tuple)))) -> Expr(Dict)))
     let module_text = locator.slice_source_code_range(&Range::from_located(expr));
     let mut tree = match_module(&module_text)?;
@@ -374,7 +411,7 @@ pub fn fix_unnecessary_literal_dict(
 
 /// (C408)
 pub fn fix_unnecessary_collection_call(
-    locator: &SourceCodeLocator,
+    locator: &Locator,
     expr: &rustpython_ast::Expr,
 ) -> Result<Fix> {
     // Expr(Call("list" | "tuple" | "dict")))) -> Expr(List|Tuple|Dict)
@@ -483,7 +520,7 @@ pub fn fix_unnecessary_collection_call(
 
 /// (C409) Convert `tuple([1, 2])` to `tuple(1, 2)`
 pub fn fix_unnecessary_literal_within_tuple_call(
-    locator: &SourceCodeLocator,
+    locator: &Locator,
     expr: &rustpython_ast::Expr,
 ) -> Result<Fix> {
     let module_text = locator.slice_source_code_range(&Range::from_located(expr));
@@ -537,7 +574,7 @@ pub fn fix_unnecessary_literal_within_tuple_call(
 
 /// (C410) Convert `list([1, 2])` to `[1, 2]`
 pub fn fix_unnecessary_literal_within_list_call(
-    locator: &SourceCodeLocator,
+    locator: &Locator,
     expr: &rustpython_ast::Expr,
 ) -> Result<Fix> {
     let module_text = locator.slice_source_code_range(&Range::from_located(expr));
@@ -592,10 +629,7 @@ pub fn fix_unnecessary_literal_within_list_call(
 }
 
 /// (C411) Convert `list([i * i for i in x])` to `[i * i for i in x]`.
-pub fn fix_unnecessary_list_call(
-    locator: &SourceCodeLocator,
-    expr: &rustpython_ast::Expr,
-) -> Result<Fix> {
+pub fn fix_unnecessary_list_call(locator: &Locator, expr: &rustpython_ast::Expr) -> Result<Fix> {
     // Expr(Call(List|Tuple)))) -> Expr(List|Tuple)))
     let module_text = locator.slice_source_code_range(&Range::from_located(expr));
     let mut tree = match_module(&module_text)?;
@@ -619,7 +653,7 @@ pub fn fix_unnecessary_list_call(
 /// (C413) Convert `reversed(sorted([2, 3, 1]))` to `sorted([2, 3, 1],
 /// reverse=True)`.
 pub fn fix_unnecessary_call_around_sorted(
-    locator: &SourceCodeLocator,
+    locator: &Locator,
     expr: &rustpython_ast::Expr,
 ) -> Result<Fix> {
     let module_text = locator.slice_source_code_range(&Range::from_located(expr));
@@ -701,7 +735,7 @@ pub fn fix_unnecessary_call_around_sorted(
 
 /// (C416) Convert `[i for i in x]` to `list(x)`.
 pub fn fix_unnecessary_comprehension(
-    locator: &SourceCodeLocator,
+    locator: &Locator,
     expr: &rustpython_ast::Expr,
 ) -> Result<Fix> {
     let module_text = locator.slice_source_code_range(&Range::from_located(expr));

src/flake8_comprehensions/mod.rs

@@ -1,5 +1,5 @@
 mod fixes;
-pub mod rules;
+pub(crate) mod rules;
 
 #[cfg(test)]
 mod tests {

src/flake8_comprehensions/snapshots/ruff__flake8_comprehensions__tests__C405_C405.py.snap

@@ -1,73 +1,158 @@
 ---
 source: src/flake8_comprehensions/mod.rs
-expression: checks
+expression: diagnostics
 ---
 - kind:
     UnnecessaryLiteralSet: list
   location:
     row: 1
-    column: 5
+    column: 0
   end_location:
     row: 1
-    column: 16
+    column: 11
   fix:
     content: "{1, 2}"
     location:
       row: 1
-      column: 5
+      column: 0
     end_location:
       row: 1
-      column: 16
+      column: 11
   parent: ~
 - kind:
     UnnecessaryLiteralSet: tuple
   location:
     row: 2
-    column: 5
+    column: 0
   end_location:
     row: 2
-    column: 16
+    column: 11
   fix:
     content: "{1, 2}"
     location:
       row: 2
-      column: 5
+      column: 0
     end_location:
       row: 2
-      column: 16
+      column: 11
   parent: ~
 - kind:
     UnnecessaryLiteralSet: list
   location:
     row: 3
-    column: 5
+    column: 0
   end_location:
     row: 3
-    column: 12
+    column: 7
   fix:
     content: set()
     location:
       row: 3
-      column: 5
+      column: 0
     end_location:
       row: 3
-      column: 12
+      column: 7
   parent: ~
 - kind:
     UnnecessaryLiteralSet: tuple
   location:
     row: 4
-    column: 5
+    column: 0
   end_location:
     row: 4
-    column: 12
+    column: 7
   fix:
     content: set()
     location:
       row: 4
-      column: 5
+      column: 0
     end_location:
       row: 4
-      column: 12
+      column: 7
+  parent: ~
+- kind:
+    UnnecessaryLiteralSet: tuple
+  location:
+    row: 6
+    column: 0
+  end_location:
+    row: 6
+    column: 9
+  fix:
+    content: "{1}"
+    location:
+      row: 6
+      column: 0
+    end_location:
+      row: 6
+      column: 9
+  parent: ~
+- kind:
+    UnnecessaryLiteralSet: tuple
+  location:
+    row: 7
+    column: 0
+  end_location:
+    row: 9
+    column: 2
+  fix:
+    content: "{\n    1,\n}"
+    location:
+      row: 7
+      column: 0
+    end_location:
+      row: 9
+      column: 2
+  parent: ~
+- kind:
+    UnnecessaryLiteralSet: list
+  location:
+    row: 10
+    column: 0
+  end_location:
+    row: 12
+    column: 2
+  fix:
+    content: "{\n    1,\n}"
+    location:
+      row: 10
+      column: 0
+    end_location:
+      row: 12
+      column: 2
+  parent: ~
+- kind:
+    UnnecessaryLiteralSet: tuple
+  location:
+    row: 13
+    column: 0
+  end_location:
+    row: 15
+    column: 1
+  fix:
+    content: "{1}"
+    location:
+      row: 13
+      column: 0
+    end_location:
+      row: 15
+      column: 1
+  parent: ~
+- kind:
+    UnnecessaryLiteralSet: list
+  location:
+    row: 16
+    column: 0
+  end_location:
+    row: 18
+    column: 1
+  fix:
+    content: "{1,}"
+    location:
+      row: 16
+      column: 0
+    end_location:
+      row: 18
+      column: 1
   parent: ~
 

src/flake8_datetimez/mod.rs

@@ -1,4 +1,4 @@
-pub mod rules;
+pub(crate) mod rules;
 
 #[cfg(test)]
 mod tests {

src/flake8_datetimez/rules.rs

@@ -1,8 +1,6 @@
 use rustpython_ast::{Constant, Expr, ExprKind, Keyword};
 
-use crate::ast::helpers::{
-    collect_call_paths, dealias_call_path, has_non_none_keyword, is_const_none, match_call_path,
-};
+use crate::ast::helpers::{has_non_none_keyword, is_const_none};
 use crate::ast::types::Range;
 use crate::checkers::ast::Checker;
 use crate::registry::Diagnostic;
@@ -15,8 +13,10 @@ pub fn call_datetime_without_tzinfo(
     keywords: &[Keyword],
     location: Range,
 ) {
-    let call_path = dealias_call_path(collect_call_paths(func), &checker.import_aliases);
-    if !match_call_path(&call_path, "datetime", "datetime", &checker.from_imports) {
+    if !checker
+        .resolve_call_path(func)
+        .map_or(false, |call_path| call_path == ["datetime", "datetime"])
+    {
         return;
     }
 
@@ -40,13 +40,9 @@ pub fn call_datetime_without_tzinfo(
 
 /// DTZ002
 pub fn call_datetime_today(checker: &mut Checker, func: &Expr, location: Range) {
-    let call_path = dealias_call_path(collect_call_paths(func), &checker.import_aliases);
-    if match_call_path(
-        &call_path,
-        "datetime.datetime",
-        "today",
-        &checker.from_imports,
-    ) {
+    if checker.resolve_call_path(func).map_or(false, |call_path| {
+        call_path == ["datetime", "datetime", "today"]
+    }) {
         checker
             .diagnostics
             .push(Diagnostic::new(violations::CallDatetimeToday, location));
@@ -55,13 +51,9 @@ pub fn call_datetime_today(checker: &mut Checker, func: &Expr, location: Range)
 
 /// DTZ003
 pub fn call_datetime_utcnow(checker: &mut Checker, func: &Expr, location: Range) {
-    let call_path = dealias_call_path(collect_call_paths(func), &checker.import_aliases);
-    if match_call_path(
-        &call_path,
-        "datetime.datetime",
-        "utcnow",
-        &checker.from_imports,
-    ) {
+    if checker.resolve_call_path(func).map_or(false, |call_path| {
+        call_path == ["datetime", "datetime", "utcnow"]
+    }) {
         checker
             .diagnostics
             .push(Diagnostic::new(violations::CallDatetimeUtcnow, location));
@@ -70,13 +62,9 @@ pub fn call_datetime_utcnow(checker: &mut Checker, func: &Expr, location: Range)
 
 /// DTZ004
 pub fn call_datetime_utcfromtimestamp(checker: &mut Checker, func: &Expr, location: Range) {
-    let call_path = dealias_call_path(collect_call_paths(func), &checker.import_aliases);
-    if match_call_path(
-        &call_path,
-        "datetime.datetime",
-        "utcfromtimestamp",
-        &checker.from_imports,
-    ) {
+    if checker.resolve_call_path(func).map_or(false, |call_path| {
+        call_path == ["datetime", "datetime", "utcfromtimestamp"]
+    }) {
         checker.diagnostics.push(Diagnostic::new(
             violations::CallDatetimeUtcfromtimestamp,
             location,
@@ -92,13 +80,9 @@ pub fn call_datetime_now_without_tzinfo(
     keywords: &[Keyword],
     location: Range,
 ) {
-    let call_path = dealias_call_path(collect_call_paths(func), &checker.import_aliases);
-    if !match_call_path(
-        &call_path,
-        "datetime.datetime",
-        "now",
-        &checker.from_imports,
-    ) {
+    if !checker.resolve_call_path(func).map_or(false, |call_path| {
+        call_path == ["datetime", "datetime", "now"]
+    }) {
         return;
     }
 
@@ -137,13 +121,9 @@ pub fn call_datetime_fromtimestamp(
     keywords: &[Keyword],
     location: Range,
 ) {
-    let call_path = dealias_call_path(collect_call_paths(func), &checker.import_aliases);
-    if !match_call_path(
-        &call_path,
-        "datetime.datetime",
-        "fromtimestamp",
-        &checker.from_imports,
-    ) {
+    if !checker.resolve_call_path(func).map_or(false, |call_path| {
+        call_path == ["datetime", "datetime", "fromtimestamp"]
+    }) {
         return;
     }
 
@@ -181,13 +161,9 @@ pub fn call_datetime_strptime_without_zone(
     args: &[Expr],
     location: Range,
 ) {
-    let call_path = dealias_call_path(collect_call_paths(func), &checker.import_aliases);
-    if !match_call_path(
-        &call_path,
-        "datetime.datetime",
-        "strptime",
-        &checker.from_imports,
-    ) {
+    if !checker.resolve_call_path(func).map_or(false, |call_path| {
+        call_path == ["datetime", "datetime", "strptime"]
+    }) {
         return;
     }
 
@@ -234,8 +210,9 @@ pub fn call_datetime_strptime_without_zone(
 
 /// DTZ011
 pub fn call_date_today(checker: &mut Checker, func: &Expr, location: Range) {
-    let call_path = dealias_call_path(collect_call_paths(func), &checker.import_aliases);
-    if match_call_path(&call_path, "datetime.date", "today", &checker.from_imports) {
+    if checker.resolve_call_path(func).map_or(false, |call_path| {
+        call_path == ["datetime", "date", "today"]
+    }) {
         checker
             .diagnostics
             .push(Diagnostic::new(violations::CallDateToday, location));
@@ -244,13 +221,9 @@ pub fn call_date_today(checker: &mut Checker, func: &Expr, location: Range) {
 
 /// DTZ012
 pub fn call_date_fromtimestamp(checker: &mut Checker, func: &Expr, location: Range) {
-    let call_path = dealias_call_path(collect_call_paths(func), &checker.import_aliases);
-    if match_call_path(
-        &call_path,
-        "datetime.date",
-        "fromtimestamp",
-        &checker.from_imports,
-    ) {
+    if checker.resolve_call_path(func).map_or(false, |call_path| {
+        call_path == ["datetime", "date", "fromtimestamp"]
+    }) {
         checker
             .diagnostics
             .push(Diagnostic::new(violations::CallDateFromtimestamp, location));

src/flake8_debugger/mod.rs

@@ -1,5 +1,5 @@
-pub mod rules;
-pub mod types;
+pub(crate) mod rules;
+pub(crate) mod types;
 
 #[cfg(test)]
 mod tests {