Use #[cold] attribute on non-ASCII lexer path

## Summary

Adds autofix for
[B033](https://docs.astral.sh/ruff/rules/duplicate-value/)

## Test Plan

`cargo test`

CHANGELOG.md

@@ -1,5 +1,66 @@
 # Changelog
 
+## 0.1.13
+
+### Bug fixes
+
+- Include base pyproject when initializing cache settings ([#9480](https://github.com/astral-sh/ruff/pull/9480))
+- \[`flake8-simplify`\] Account for possibly-empty f-string values in truthiness logic ([#9484](https://github.com/astral-sh/ruff/pull/9484))
+- \[`pylint`\] Add the missing period in `unnecessary-dunder-call` ([#9485](https://github.com/astral-sh/ruff/pull/9485))
+- \[`pylint`\] Fix `__aenter__` message in `unnecessary-dunder-call` ([#9492](https://github.com/astral-sh/ruff/pull/9492))
+
+## 0.1.12
+
+### Preview features
+
+- Formatter: Hug multiline-strings in preview style ([#9243](https://github.com/astral-sh/ruff/pull/9243))
+- \[`flake8-bandit`\] Add `ssl-with-no-version` (`S504`) ([#9384](https://github.com/astral-sh/ruff/pull/9384))
+- \[`flake8-bandit`\] Implement `ssl-insecure-version` (`S502`) ([#9390](https://github.com/astral-sh/ruff/pull/9390))
+- \[`flake8-bandit`\] Implement `ssl-with-bad-defaults` (`S503`) ([#9391](https://github.com/astral-sh/ruff/pull/9391))
+- \[`flake8-bandit`\] Implement suspicious import rules (`S4XX`) ([#8831](https://github.com/astral-sh/ruff/pull/8831))
+- \[`flake8-simplify`\] Implement `zip-dict-keys-and-values` (`SIM911`) ([#9460](https://github.com/astral-sh/ruff/pull/9460))
+- \[`pyflakes`\] Add a fix for `redefined-while-unused` (`F811`) ([#9419](https://github.com/astral-sh/ruff/pull/9419))
+- \[`pylint`\] Implement `unnecessary-dunder-call` (`C2801`) ([#9166](https://github.com/astral-sh/ruff/pull/9166))
+- \[`ruff`\] Add `parenthesize-chained-operators` (`RUF021`) to enforce parentheses in `a or b and c` ([#9440](https://github.com/astral-sh/ruff/pull/9440))
+
+### Rule changes
+
+- \[`flake8-boolean-trap`\] Allow Boolean positional arguments in setters ([#9429](https://github.com/astral-sh/ruff/pull/9429))
+- \[`flake8-builtins`\] Restrict `builtin-attribute-shadowing` (`A003`) to actual shadowed references ([#9462](https://github.com/astral-sh/ruff/pull/9462))
+- \[`flake8-pyi`\] Add fix for `generator-return-from-iter-method` (`PYI058`) ([#9355](https://github.com/astral-sh/ruff/pull/9355))
+- \[`pyflakes`\] Don't flag `redefined-while-unused` (`F811`) in `if` branches ([#9418](https://github.com/astral-sh/ruff/pull/9418))
+- \[`pyupgrade`\] Add some additional Python 3.12 typing members to `deprecated-import` ([#9445](https://github.com/astral-sh/ruff/pull/9445))
+- \[`ruff`\] Add fix for `parenthesize-chained-operators` (`RUF021`) ([#9449](https://github.com/astral-sh/ruff/pull/9449))
+- \[`ruff`\] Include subscripts and attributes in static key rule (`RUF011`) ([#9416](https://github.com/astral-sh/ruff/pull/9416))
+- \[`ruff`\] Support variable keys in static dictionary key rule (`RUF011`) ([#9411](https://github.com/astral-sh/ruff/pull/9411))
+
+### Formatter
+
+- Generate deterministic IDs when formatting notebooks ([#9359](https://github.com/astral-sh/ruff/pull/9359))
+- Allow `# fmt: skip` with interspersed same-line comments ([#9395](https://github.com/astral-sh/ruff/pull/9395))
+- Parenthesize breaking named expressions in match guards ([#9396](https://github.com/astral-sh/ruff/pull/9396))
+
+### Bug fixes
+
+- Add cell indexes to all diagnostics ([#9387](https://github.com/astral-sh/ruff/pull/9387))
+- Avoid infinite loop in constant vs. `None` comparisons ([#9376](https://github.com/astral-sh/ruff/pull/9376))
+- Handle raises with implicit alternate branches ([#9377](https://github.com/astral-sh/ruff/pull/9377))
+- Ignore trailing quotes for unclosed l-brace errors ([#9388](https://github.com/astral-sh/ruff/pull/9388))
+- Respect multi-segment submodule imports when resolving qualified names ([#9382](https://github.com/astral-sh/ruff/pull/9382))
+- Use `DisplayParseError` for stdin parser errors ([#9409](https://github.com/astral-sh/ruff/pull/9409))
+- Use `comment_ranges` for isort directive extraction ([#9414](https://github.com/astral-sh/ruff/pull/9414))
+- Use transformed source code for diagnostic locations ([#9408](https://github.com/astral-sh/ruff/pull/9408))
+- \[`flake8-pyi`\] Exclude `warnings.deprecated` and `typing_extensions.deprecated` arguments ([#9423](https://github.com/astral-sh/ruff/pull/9423))
+- \[`flake8-pyi`\] Fix false negative for `unused-private-protocol` (`PYI046`) with unused generic protocols ([#9405](https://github.com/astral-sh/ruff/pull/9405))
+- \[`pydocstyle`\] Disambiguate argument descriptors from section headers ([#9427](https://github.com/astral-sh/ruff/pull/9427))
+- \[`pylint`\] Homogenize `PLR0914` message to match other `PLR09XX` rules ([#9399](https://github.com/astral-sh/ruff/pull/9399))
+- \[`ruff`\] Allow `Hashable = None` in type annotations (`RUF013`) ([#9442](https://github.com/astral-sh/ruff/pull/9442))
+
+### Documentation
+
+- Fix admonition hyperlink colouring ([#9385](https://github.com/astral-sh/ruff/pull/9385))
+- Add missing preview link ([#9386](https://github.com/astral-sh/ruff/pull/9386))
+
 ## 0.1.11
 
 ### Preview features

Cargo.lock

@@ -123,9 +123,9 @@ dependencies = [
 
 [[package]]
 name = "anyhow"
-version = "1.0.76"
+version = "1.0.79"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "59d2a3357dde987206219e78ecfbbb6e8dad06cbb65292758d3270e6254f7355"
+checksum = "080e9890a082662b09c1ad45f567faeeb47f22b5fb23895fbe1e651e718e25ca"
 
 [[package]]
 name = "argfile"
@@ -312,9 +312,9 @@ dependencies = [
 
 [[package]]
 name = "clap"
-version = "4.4.12"
+version = "4.4.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dcfab8ba68f3668e89f6ff60f5b205cea56aa7b769451a59f34b8682f51c056d"
+checksum = "52bdc885e4cacc7f7c9eedc1ef6da641603180c783c41a15c264944deeaab642"
 dependencies = [
  "clap_builder",
  "clap_derive",
@@ -382,7 +382,7 @@ dependencies = [
  "heck",
  "proc-macro2",
  "quote",
- "syn 2.0.40",
+ "syn 2.0.48",
 ]
 
 [[package]]
@@ -600,7 +600,7 @@ dependencies = [
  "proc-macro2",
  "quote",
  "strsim",
- "syn 2.0.40",
+ "syn 2.0.48",
 ]
 
 [[package]]
@@ -611,7 +611,7 @@ checksum = "836a9bbc7ad63342d6d6e7b815ccab164bc77a2d95d84bc3117a8c0d5c98e2d5"
 dependencies = [
  "darling_core",
  "quote",
- "syn 2.0.40",
+ "syn 2.0.48",
 ]
 
 [[package]]
@@ -748,23 +748,12 @@ checksum = "5443807d6dff69373d433ab9ef5378ad8df50ca6298caf15de6e52e24aaf54d5"
 
 [[package]]
 name = "errno"
-version = "0.3.3"
+version = "0.3.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "136526188508e25c6fef639d7927dfb3e0e3084488bf202267829cf7fc23dbdd"
+checksum = "a258e46cdc063eb8519c00b9fc845fc47bcfca4130e2f08e88665ceda8474245"
 dependencies = [
- "errno-dragonfly",
- "libc",
- "windows-sys 0.48.0",
-]
-
-[[package]]
-name = "errno-dragonfly"
-version = "0.1.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "aa68f1b12764fab894d2755d2518754e71b4fd80ecfb822714a1206c2aab39bf"
-dependencies = [
- "cc",
  "libc",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
@@ -1107,7 +1096,7 @@ dependencies = [
  "Inflector",
  "proc-macro2",
  "quote",
- "syn 2.0.40",
+ "syn 2.0.48",
 ]
 
 [[package]]
@@ -1250,9 +1239,9 @@ dependencies = [
 
 [[package]]
 name = "libc"
-version = "0.2.149"
+version = "0.2.152"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a08173bc88b7955d1b3145aa561539096c421ac8debde8cbc3612ec635fee29b"
+checksum = "13e3bf6590cbc649f4d1a3eefc9d5d6eb746f5200ffb04e5e142700b8faa56e7"
 
 [[package]]
 name = "libcst"
@@ -1297,9 +1286,9 @@ checksum = "0717cef1bc8b636c6e1c1bbdefc09e6322da8a9321966e8928ef80d20f7f770f"
 
 [[package]]
 name = "linux-raw-sys"
-version = "0.4.10"
+version = "0.4.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "da2479e8c062e40bf0066ffa0bc823de0a9368974af99c9f6df941d2c231e03f"
+checksum = "c4cd1a83af159aa67994778be9070f0ae1bd732942279cabb14f86f986a21456"
 
 [[package]]
 name = "lock_api"
@@ -1696,7 +1685,7 @@ checksum = "52a40bc70c2c58040d2d8b167ba9a5ff59fc9dab7ad44771cfde3dcfde7a09c6"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.40",
+ "syn 2.0.48",
 ]
 
 [[package]]
@@ -1781,9 +1770,9 @@ dependencies = [
 
 [[package]]
 name = "proc-macro2"
-version = "1.0.73"
+version = "1.0.76"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2dd5e8a1f1029c43224ad5898e50140c2aebb1705f19e67c918ebf5b9e797fe1"
+checksum = "95fc56cda0b5c3325f5fbbd7ff9fda9e02bb00bb3dac51252d2f1bfa1cb8cc8c"
 dependencies = [
  "unicode-ident",
 ]
@@ -1827,9 +1816,9 @@ dependencies = [
 
 [[package]]
 name = "quote"
-version = "1.0.33"
+version = "1.0.35"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5267fca4496028628a95160fc423a33e8b2e6af8a5302579e322e4b520293cae"
+checksum = "291ec9ab5efd934aaf503a6466c5d5251535d108ee747472c3977cc5acc868ef"
 dependencies = [
  "proc-macro2",
 ]
@@ -1996,7 +1985,7 @@ dependencies = [
  "pmutil",
  "proc-macro2",
  "quote",
- "syn 2.0.40",
+ "syn 2.0.48",
 ]
 
 [[package]]
@@ -2049,7 +2038,7 @@ dependencies = [
 
 [[package]]
 name = "ruff_cli"
-version = "0.1.11"
+version = "0.1.13"
 dependencies = [
  "anyhow",
  "argfile",
@@ -2176,7 +2165,7 @@ dependencies = [
 
 [[package]]
 name = "ruff_linter"
-version = "0.1.11"
+version = "0.1.13"
 dependencies = [
  "aho-corasick",
  "annotate-snippets 0.9.2",
@@ -2248,7 +2237,7 @@ dependencies = [
  "proc-macro2",
  "quote",
  "ruff_python_trivia",
- "syn 2.0.40",
+ "syn 2.0.48",
 ]
 
 [[package]]
@@ -2428,7 +2417,7 @@ dependencies = [
 
 [[package]]
 name = "ruff_shrinking"
-version = "0.1.11"
+version = "0.1.13"
 dependencies = [
  "anyhow",
  "clap",
@@ -2539,15 +2528,15 @@ checksum = "08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2"
 
 [[package]]
 name = "rustix"
-version = "0.38.21"
+version = "0.38.28"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2b426b0506e5d50a7d8dafcf2e81471400deb602392c7dd110815afb4eaf02a3"
+checksum = "72e572a5e8ca657d7366229cdde4bd14c4eb5499a9573d4d366fe1b599daa316"
 dependencies = [
  "bitflags 2.4.1",
  "errno",
  "libc",
  "linux-raw-sys",
- "windows-sys 0.48.0",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
@@ -2653,9 +2642,9 @@ checksum = "836fa6a3e1e547f9a2c4040802ec865b5d85f4014efe00555d7090a3dcaa1090"
 
 [[package]]
 name = "serde"
-version = "1.0.193"
+version = "1.0.195"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "25dd9975e68d0cb5aa1120c288333fc98731bd1dd12f561e468ea4728c042b89"
+checksum = "63261df402c67811e9ac6def069e4786148c4563f4b50fd4bf30aa370d626b02"
 dependencies = [
  "serde_derive",
 ]
@@ -2673,13 +2662,13 @@ dependencies = [
 
 [[package]]
 name = "serde_derive"
-version = "1.0.193"
+version = "1.0.195"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "43576ca501357b9b071ac53cdc7da8ef0cbd9493d8df094cd821777ea6e894d3"
+checksum = "46fe8f8603d81ba86327b23a2e9cdf49e1255fb94a4c5f297f6ee0547178ea2c"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.40",
+ "syn 2.0.48",
 ]
 
 [[package]]
@@ -2741,7 +2730,7 @@ dependencies = [
  "darling",
  "proc-macro2",
  "quote",
- "syn 2.0.40",
+ "syn 2.0.48",
 ]
 
 [[package]]
@@ -2845,7 +2834,7 @@ dependencies = [
  "proc-macro2",
  "quote",
  "rustversion",
- "syn 2.0.40",
+ "syn 2.0.48",
 ]
 
 [[package]]
@@ -2861,9 +2850,9 @@ dependencies = [
 
 [[package]]
 name = "syn"
-version = "2.0.40"
+version = "2.0.48"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "13fa70a4ee923979ffb522cacce59d34421ebdea5625e1073c4326ef9d2dd42e"
+checksum = "0f3531638e407dfc0814761abb7c00a5b54992b849452a0646b7f65c9f770f3f"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -2872,15 +2861,15 @@ dependencies = [
 
 [[package]]
 name = "tempfile"
-version = "3.8.1"
+version = "3.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7ef1adac450ad7f4b3c28589471ade84f25f731a7a0fe30d71dfa9f60fd808e5"
+checksum = "01ce4141aa927a6d1bd34a041795abd0db1cccba5d5f24b009f694bdf3a1f3fa"
 dependencies = [
  "cfg-if",
  "fastrand",
  "redox_syscall 0.4.1",
  "rustix",
- "windows-sys 0.48.0",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
@@ -2941,7 +2930,7 @@ dependencies = [
  "proc-macro-error",
  "proc-macro2",
  "quote",
- "syn 2.0.40",
+ "syn 2.0.48",
 ]
 
 [[package]]
@@ -2953,7 +2942,7 @@ dependencies = [
  "proc-macro-error",
  "proc-macro2",
  "quote",
- "syn 2.0.40",
+ "syn 2.0.48",
  "test-case-core",
 ]
 
@@ -2974,7 +2963,7 @@ checksum = "01742297787513b79cf8e29d1056ede1313e2420b7b3b15d0a768b4921f549df"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.40",
+ "syn 2.0.48",
 ]
 
 [[package]]
@@ -3111,7 +3100,7 @@ checksum = "34704c8d6ebcbc939824180af020566b01a7c01f80641264eba0999f6c2b6be7"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.40",
+ "syn 2.0.48",
 ]
 
 [[package]]
@@ -3329,7 +3318,7 @@ checksum = "f49e7f3f3db8040a100710a11932239fd30697115e2ba4107080d8252939845e"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.40",
+ "syn 2.0.48",
 ]
 
 [[package]]
@@ -3423,7 +3412,7 @@ dependencies = [
  "once_cell",
  "proc-macro2",
  "quote",
- "syn 2.0.40",
+ "syn 2.0.48",
  "wasm-bindgen-shared",
 ]
 
@@ -3457,7 +3446,7 @@ checksum = "f0eb82fcb7930ae6219a7ecfd55b217f5f0893484b7a13022ebb2b2bf20b5283"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.40",
+ "syn 2.0.48",
  "wasm-bindgen-backend",
  "wasm-bindgen-shared",
 ]
@@ -3490,7 +3479,7 @@ checksum = "794645f5408c9a039fd09f4d113cdfb2e7eba5ff1956b07bcf701cf4b394fe89"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.40",
+ "syn 2.0.48",
 ]
 
 [[package]]
@@ -3817,5 +3806,5 @@ checksum = "be912bf68235a88fbefd1b73415cb218405958d1655b2ece9035a19920bdf6ba"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.40",
+ "syn 2.0.48",
 ]

Cargo.toml

@@ -14,14 +14,14 @@ license = "MIT"
 [workspace.dependencies]
 aho-corasick = { version = "1.1.2" }
 annotate-snippets = { version = "0.9.2", features = ["color"] }
-anyhow = { version = "1.0.76" }
+anyhow = { version = "1.0.79" }
 argfile = { version = "0.1.6" }
 assert_cmd = { version = "2.0.8" }
 bincode = { version = "1.3.3" }
 bitflags = { version = "2.4.1" }
 cachedir = { version = "0.3.1" }
 chrono = { version = "0.4.31", default-features = false, features = ["clock"] }
-clap = { version = "4.4.12", features = ["derive"] }
+clap = { version = "4.4.13", features = ["derive"] }
 clap_complete_command = { version = "0.5.1" }
 clearscreen = { version = "2.0.0" }
 codspeed-criterion-compat = { version = "2.3.3", default-features = false }
@@ -76,7 +76,7 @@ rustc-hash = { version = "1.1.0" }
 schemars = { version = "0.8.16" }
 seahash = { version ="4.1.0"}
 semver = { version = "1.0.20" }
-serde = { version = "1.0.193", features = ["derive"] }
+serde = { version = "1.0.195", features = ["derive"] }
 serde-wasm-bindgen = { version = "0.6.3" }
 serde_json = { version = "1.0.109" }
 serde_test = { version = "1.0.152" }
@@ -89,7 +89,7 @@ static_assertions = "1.1.0"
 strum = { version = "0.25.0", features = ["strum_macros"] }
 strum_macros = { version = "0.25.3" }
 syn = { version = "2.0.40" }
-tempfile = { version ="3.8.1"}
+tempfile = { version ="3.9.0"}
 test-case = { version = "3.3.1" }
 thiserror = { version = "1.0.51" }
 tikv-jemallocator = { version ="0.5.0"}

README.md

@@ -150,7 +150,7 @@ Ruff can also be used as a [pre-commit](https://pre-commit.com/) hook via [`ruff
 ```yaml
 - repo: https://github.com/astral-sh/ruff-pre-commit
   # Ruff version.
-  rev: v0.1.11
+  rev: v0.1.13
   hooks:
     # Run the linter.
     - id: ruff
@@ -418,6 +418,7 @@ Ruff is used by a number of major open-source projects and companies, including:
 - Netflix ([Dispatch](https://github.com/Netflix/dispatch))
 - [Neon](https://github.com/neondatabase/neon)
 - [NoneBot](https://github.com/nonebot/nonebot2)
+- [NumPyro](https://github.com/pyro-ppl/numpyro)
 - [ONNX](https://github.com/onnx/onnx)
 - [OpenBB](https://github.com/OpenBB-finance/OpenBBTerminal)
 - [PDM](https://github.com/pdm-project/pdm)
@@ -429,6 +430,7 @@ Ruff is used by a number of major open-source projects and companies, including:
 - [PostHog](https://github.com/PostHog/posthog)
 - Prefect ([Python SDK](https://github.com/PrefectHQ/prefect), [Marvin](https://github.com/PrefectHQ/marvin))
 - [PyInstaller](https://github.com/pyinstaller/pyinstaller)
+- [PyMC](https://github.com/pymc-devs/pymc/)
 - [PyMC-Marketing](https://github.com/pymc-labs/pymc-marketing)
 - [PyTorch](https://github.com/pytorch/pytorch)
 - [Pydantic](https://github.com/pydantic/pydantic)

crates/ruff_benchmark/benches/linter.rs

@@ -55,7 +55,7 @@ fn benchmark_linter(mut group: BenchmarkGroup, settings: &LinterSettings) {
             &case,
             |b, case| {
                 // Tokenize the source.
-                let tokens = lexer::lex(case.code(), Mode::Module).collect::<Vec<_>>();
+                let tokens: Vec<_> = lexer::lex(case.code(), Mode::Module).collect();
 
                 // Parse the source.
                 let ast = parse_program_tokens(tokens.clone(), case.code(), false).unwrap();

crates/ruff_cli/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ruff_cli"
-version = "0.1.11"
+version = "0.1.13"
 publish = false
 authors = { workspace = true }
 edition = { workspace = true }

crates/ruff_cli/src/args.rs

@@ -290,6 +290,10 @@ pub struct CheckCommand {
     /// The name of the file when passing it through stdin.
     #[arg(long, help_heading = "Miscellaneous")]
     pub stdin_filename: Option<PathBuf>,
+    /// List of mappings from file extension to language (one of ["python", "ipynb", "pyi"]). For
+    /// example, to treat `.ipy` files as IPython notebooks, use `--extension ipy:ipynb`.
+    #[arg(long, value_delimiter = ',')]
+    pub extension: Option<Vec<ExtensionPair>>,
     /// Exit with status code "0", even upon detecting lint violations.
     #[arg(
         short,
@@ -352,9 +356,6 @@ pub struct CheckCommand {
         conflicts_with = "watch",
     )]
     pub show_settings: bool,
-    /// List of mappings from file extension to language (one of ["python", "ipynb", "pyi"]).
-    #[arg(long, value_delimiter = ',', hide = true)]
-    pub extension: Option<Vec<ExtensionPair>>,
     /// Dev-only argument to show fixes
     #[arg(long, hide = true)]
     pub ecosystem_ci: bool,
@@ -423,6 +424,10 @@ pub struct FormatCommand {
     /// The name of the file when passing it through stdin.
     #[arg(long, help_heading = "Miscellaneous")]
     pub stdin_filename: Option<PathBuf>,
+    /// List of mappings from file extension to language (one of ["python", "ipynb", "pyi"]). For
+    /// example, to treat `.ipy` files as IPython notebooks, use `--extension ipy:ipynb`.
+    #[arg(long, value_delimiter = ',')]
+    pub extension: Option<Vec<ExtensionPair>>,
     /// The minimum Python version that should be supported.
     #[arg(long, value_enum)]
     pub target_version: Option<PythonVersion>,
@@ -571,6 +576,7 @@ impl FormatCommand {
                 force_exclude: resolve_bool_arg(self.force_exclude, self.no_force_exclude),
                 target_version: self.target_version,
                 cache_dir: self.cache_dir,
+                extension: self.extension,
 
                 // Unsupported on the formatter CLI, but required on `Overrides`.
                 ..CliOverrides::default()
@@ -739,7 +745,7 @@ impl ConfigurationTransformer for CliOverrides {
             config.target_version = Some(*target_version);
         }
         if let Some(extension) = &self.extension {
-            config.lint.extension = Some(extension.clone().into_iter().collect());
+            config.extension = Some(extension.iter().cloned().collect());
         }
 
         config

crates/ruff_cli/src/cache.rs

@@ -25,10 +25,9 @@ use ruff_notebook::NotebookIndex;
 use ruff_python_ast::imports::ImportMap;
 use ruff_source_file::SourceFileBuilder;
 use ruff_text_size::{TextRange, TextSize};
-use ruff_workspace::resolver::{PyprojectConfig, PyprojectDiscoveryStrategy, Resolver};
+use ruff_workspace::resolver::Resolver;
 use ruff_workspace::Settings;
 
-use crate::cache;
 use crate::diagnostics::Diagnostics;
 
 /// [`Path`] that is relative to the package root in [`PackageCache`].
@@ -86,6 +85,7 @@ pub(crate) struct Cache {
     changes: Mutex<Vec<Change>>,
     /// The "current" timestamp used as cache for the updates of
     /// [`FileCache::last_seen`]
+    #[allow(clippy::struct_field_names)]
     last_seen_cache: u64,
 }
 
@@ -442,7 +442,7 @@ pub(super) struct CacheMessage {
 pub(crate) trait PackageCaches {
     fn get(&self, package_root: &Path) -> Option<&Cache>;
 
-    fn persist(self) -> anyhow::Result<()>;
+    fn persist(self) -> Result<()>;
 }
 
 impl<T> PackageCaches for Option<T>
@@ -468,27 +468,17 @@ pub(crate) struct PackageCacheMap<'a>(FxHashMap<&'a Path, Cache>);
 
 impl<'a> PackageCacheMap<'a> {
     pub(crate) fn init(
-        pyproject_config: &PyprojectConfig,
         package_roots: &FxHashMap<&'a Path, Option<&'a Path>>,
         resolver: &Resolver,
     ) -> Self {
         fn init_cache(path: &Path) {
-            if let Err(e) = cache::init(path) {
+            if let Err(e) = init(path) {
                 error!("Failed to initialize cache at {}: {e:?}", path.display());
             }
         }
 
-        match pyproject_config.strategy {
-            PyprojectDiscoveryStrategy::Fixed => {
-                init_cache(&pyproject_config.settings.cache_dir);
-            }
-            PyprojectDiscoveryStrategy::Hierarchical => {
-                for settings in
-                    std::iter::once(&pyproject_config.settings).chain(resolver.settings())
-                {
-                    init_cache(&settings.cache_dir);
-                }
-            }
+        for settings in resolver.settings() {
+            init_cache(&settings.cache_dir);
         }
 
         Self(
@@ -498,7 +488,7 @@ impl<'a> PackageCacheMap<'a> {
                 .unique()
                 .par_bridge()
                 .map(|cache_root| {
-                    let settings = resolver.resolve(cache_root, pyproject_config);
+                    let settings = resolver.resolve(cache_root);
                     let cache = Cache::open(cache_root.to_path_buf(), settings);
                     (cache_root, cache)
                 })

crates/ruff_cli/src/commands/add_noqa.rs

@@ -38,7 +38,6 @@ pub(crate) fn add_noqa(
             .flatten()
             .map(ResolvedFile::path)
             .collect::<Vec<_>>(),
-        pyproject_config,
     );
 
     let start = Instant::now();
@@ -57,7 +56,7 @@ pub(crate) fn add_noqa(
                 .parent()
                 .and_then(|parent| package_roots.get(parent))
                 .and_then(|package| *package);
-            let settings = resolver.resolve(path, pyproject_config);
+            let settings = resolver.resolve(path);
             let source_kind = match SourceKind::from_path(path, source_type) {
                 Ok(Some(source_kind)) => source_kind,
                 Ok(None) => return None,

crates/ruff_cli/src/commands/check.rs

@@ -57,16 +57,11 @@ pub(crate) fn check(
             .flatten()
             .map(ResolvedFile::path)
             .collect::<Vec<_>>(),
-        pyproject_config,
     );
 
     // Load the caches.
     let caches = if bool::from(cache) {
-        Some(PackageCacheMap::init(
-            pyproject_config,
-            &package_roots,
-            &resolver,
-        ))
+        Some(PackageCacheMap::init(&package_roots, &resolver))
     } else {
         None
     };
@@ -81,7 +76,7 @@ pub(crate) fn check(
                     .and_then(|parent| package_roots.get(parent))
                     .and_then(|package| *package);
 
-                let settings = resolver.resolve(path, pyproject_config);
+                let settings = resolver.resolve(path);
 
                 if (settings.file_resolver.force_exclude || !resolved_file.is_root())
                     && match_exclusion(
@@ -128,7 +123,7 @@ pub(crate) fn check(
 
         Some(result.unwrap_or_else(|(path, message)| {
             if let Some(path) = &path {
-                let settings = resolver.resolve(path, pyproject_config);
+                let settings = resolver.resolve(path);
                 if settings.linter.rules.enabled(Rule::IOError) {
                     let dummy =
                         SourceFileBuilder::new(path.to_string_lossy().as_ref(), "").finish();

crates/ruff_cli/src/commands/check_stdin.rs

@@ -4,7 +4,7 @@ use anyhow::Result;
 
 use ruff_linter::packaging;
 use ruff_linter::settings::flags;
-use ruff_workspace::resolver::{match_exclusion, python_file_at_path, PyprojectConfig};
+use ruff_workspace::resolver::{match_exclusion, python_file_at_path, PyprojectConfig, Resolver};
 
 use crate::args::CliOverrides;
 use crate::diagnostics::{lint_stdin, Diagnostics};
@@ -18,20 +18,20 @@ pub(crate) fn check_stdin(
     noqa: flags::Noqa,
     fix_mode: flags::FixMode,
 ) -> Result<Diagnostics> {
-    if pyproject_config.settings.file_resolver.force_exclude {
+    let mut resolver = Resolver::new(pyproject_config);
+
+    if resolver.force_exclude() {
         if let Some(filename) = filename {
-            if !python_file_at_path(filename, pyproject_config, overrides)? {
+            if !python_file_at_path(filename, &mut resolver, overrides)? {
                 if fix_mode.is_apply() {
                     parrot_stdin()?;
                 }
                 return Ok(Diagnostics::default());
             }
 
-            let lint_settings = &pyproject_config.settings.linter;
-            if filename
-                .file_name()
-                .is_some_and(|name| match_exclusion(filename, name, &lint_settings.exclude))
-            {
+            if filename.file_name().is_some_and(|name| {
+                match_exclusion(filename, name, &resolver.base_settings().linter.exclude)
+            }) {
                 if fix_mode.is_apply() {
                     parrot_stdin()?;
                 }
@@ -41,13 +41,13 @@ pub(crate) fn check_stdin(
     }
     let stdin = read_from_stdin()?;
     let package_root = filename.and_then(Path::parent).and_then(|path| {
-        packaging::detect_package_root(path, &pyproject_config.settings.linter.namespace_packages)
+        packaging::detect_package_root(path, &resolver.base_settings().linter.namespace_packages)
     });
     let mut diagnostics = lint_stdin(
         filename,
         package_root,
         stdin,
-        &pyproject_config.settings,
+        resolver.base_settings(),
         noqa,
         fix_mode,
     )?;

crates/ruff_cli/src/commands/format.rs

@@ -25,9 +25,7 @@ use ruff_linter::warn_user_once;
 use ruff_python_ast::{PySourceType, SourceType};
 use ruff_python_formatter::{format_module_source, FormatModuleError, QuoteStyle};
 use ruff_text_size::{TextLen, TextRange, TextSize};
-use ruff_workspace::resolver::{
-    match_exclusion, python_files_in_path, PyprojectConfig, ResolvedFile, Resolver,
-};
+use ruff_workspace::resolver::{match_exclusion, python_files_in_path, ResolvedFile, Resolver};
 use ruff_workspace::FormatterSettings;
 
 use crate::args::{CliOverrides, FormatArguments};
@@ -79,7 +77,7 @@ pub(crate) fn format(
         return Ok(ExitStatus::Success);
     }
 
-    warn_incompatible_formatter_settings(&pyproject_config, Some(&resolver));
+    warn_incompatible_formatter_settings(&resolver);
 
     // Discover the package root for each Python file.
     let package_roots = resolver.package_roots(
@@ -88,7 +86,6 @@ pub(crate) fn format(
             .flatten()
             .map(ResolvedFile::path)
             .collect::<Vec<_>>(),
-        &pyproject_config,
     );
 
     let caches = if cli.no_cache {
@@ -99,11 +96,7 @@ pub(crate) fn format(
         #[cfg(debug_assertions)]
         crate::warn_user!("Detected debug build without --no-cache.");
 
-        Some(PackageCacheMap::init(
-            &pyproject_config,
-            &package_roots,
-            &resolver,
-        ))
+        Some(PackageCacheMap::init(&package_roots, &resolver))
     };
 
     let start = Instant::now();
@@ -113,12 +106,18 @@ pub(crate) fn format(
             match entry {
                 Ok(resolved_file) => {
                     let path = resolved_file.path();
-                    let SourceType::Python(source_type) = SourceType::from(&path) else {
-                        // Ignore any non-Python files.
-                        return None;
-                    };
+                    let settings = resolver.resolve(path);
 
-                    let settings = resolver.resolve(path, &pyproject_config);
+                    let source_type = match settings.formatter.extension.get(path) {
+                        None => match SourceType::from(path) {
+                            SourceType::Python(source_type) => source_type,
+                            SourceType::Toml(_) => {
+                                // Ignore any non-Python files.
+                                return None;
+                            }
+                        },
+                        Some(language) => PySourceType::from(language),
+                    };
 
                     // Ignore files that are excluded from formatting
                     if (settings.file_resolver.force_exclude || !resolved_file.is_root())
@@ -723,15 +722,10 @@ impl Display for FormatCommandError {
     }
 }
 
-pub(super) fn warn_incompatible_formatter_settings(
-    pyproject_config: &PyprojectConfig,
-    resolver: Option<&Resolver>,
-) {
+pub(super) fn warn_incompatible_formatter_settings(resolver: &Resolver) {
     // First, collect all rules that are incompatible regardless of the linter-specific settings.
     let mut incompatible_rules = FxHashSet::default();
-    for setting in std::iter::once(&pyproject_config.settings)
-        .chain(resolver.iter().flat_map(|resolver| resolver.settings()))
-    {
+    for setting in resolver.settings() {
         for rule in [
             // The formatter might collapse implicit string concatenation on a single line.
             Rule::SingleLineImplicitStringConcatenation,
@@ -760,9 +754,7 @@ pub(super) fn warn_incompatible_formatter_settings(
     }
 
     // Next, validate settings-specific incompatibilities.
-    for setting in std::iter::once(&pyproject_config.settings)
-        .chain(resolver.iter().flat_map(|resolver| resolver.settings()))
-    {
+    for setting in resolver.settings() {
         // Validate all rules that rely on tab styles.
         if setting.linter.rules.enabled(Rule::TabIndentation)
             && setting.formatter.indent_style.is_tab()

crates/ruff_cli/src/commands/format_stdin.rs

@@ -6,7 +6,7 @@ use log::error;
 
 use ruff_linter::source_kind::SourceKind;
 use ruff_python_ast::{PySourceType, SourceType};
-use ruff_workspace::resolver::{match_exclusion, python_file_at_path};
+use ruff_workspace::resolver::{match_exclusion, python_file_at_path, Resolver};
 use ruff_workspace::FormatterSettings;
 
 use crate::args::{CliOverrides, FormatArguments};
@@ -27,24 +27,23 @@ pub(crate) fn format_stdin(cli: &FormatArguments, overrides: &CliOverrides) -> R
         cli.stdin_filename.as_deref(),
     )?;
 
-    warn_incompatible_formatter_settings(&pyproject_config, None);
+    let mut resolver = Resolver::new(&pyproject_config);
+    warn_incompatible_formatter_settings(&resolver);
 
     let mode = FormatMode::from_cli(cli);
 
-    if pyproject_config.settings.file_resolver.force_exclude {
+    if resolver.force_exclude() {
         if let Some(filename) = cli.stdin_filename.as_deref() {
-            if !python_file_at_path(filename, &pyproject_config, overrides)? {
+            if !python_file_at_path(filename, &mut resolver, overrides)? {
                 if mode.is_write() {
                     parrot_stdin()?;
                 }
                 return Ok(ExitStatus::Success);
             }
 
-            let format_settings = &pyproject_config.settings.formatter;
-            if filename
-                .file_name()
-                .is_some_and(|name| match_exclusion(filename, name, &format_settings.exclude))
-            {
+            if filename.file_name().is_some_and(|name| {
+                match_exclusion(filename, name, &resolver.base_settings().formatter.exclude)
+            }) {
                 if mode.is_write() {
                     parrot_stdin()?;
                 }
@@ -54,21 +53,23 @@ pub(crate) fn format_stdin(cli: &FormatArguments, overrides: &CliOverrides) -> R
     }
 
     let path = cli.stdin_filename.as_deref();
+    let settings = &resolver.base_settings().formatter;
 
-    let SourceType::Python(source_type) = path.map(SourceType::from).unwrap_or_default() else {
-        if mode.is_write() {
-            parrot_stdin()?;
-        }
-        return Ok(ExitStatus::Success);
+    let source_type = match path.and_then(|path| settings.extension.get(path)) {
+        None => match path.map(SourceType::from).unwrap_or_default() {
+            SourceType::Python(source_type) => source_type,
+            SourceType::Toml(_) => {
+                if mode.is_write() {
+                    parrot_stdin()?;
+                }
+                return Ok(ExitStatus::Success);
+            }
+        },
+        Some(language) => PySourceType::from(language),
     };
 
     // Format the file.
-    match format_source_code(
-        path,
-        &pyproject_config.settings.formatter,
-        source_type,
-        mode,
-    ) {
+    match format_source_code(path, settings, source_type, mode) {
         Ok(result) => match mode {
             FormatMode::Write => Ok(ExitStatus::Success),
             FormatMode::Check | FormatMode::Diff => {

crates/ruff_cli/src/commands/rule.rs

@@ -18,6 +18,7 @@ struct Explanation<'a> {
     summary: &'a str,
     message_formats: &'a [&'a str],
     fix: String,
+    #[allow(clippy::struct_field_names)]
     explanation: Option<&'a str>,
     preview: bool,
 }

crates/ruff_cli/src/commands/show_settings.rs

@@ -29,13 +29,13 @@ pub(crate) fn show_settings(
         bail!("No files found under the given path");
     };
 
-    let settings = resolver.resolve(&path, pyproject_config);
+    let settings = resolver.resolve(&path);
 
     writeln!(writer, "Resolved settings for: {path:?}")?;
     if let Some(settings_path) = pyproject_config.path.as_ref() {
         writeln!(writer, "Settings path: {settings_path:?}")?;
     }
-    writeln!(writer, "{settings:#?}")?;
+    write!(writer, "{settings}")?;
 
     Ok(())
 }

crates/ruff_cli/src/diagnostics.rs

@@ -17,7 +17,7 @@ use ruff_linter::logging::DisplayParseError;
 use ruff_linter::message::Message;
 use ruff_linter::pyproject_toml::lint_pyproject_toml;
 use ruff_linter::registry::AsRule;
-use ruff_linter::settings::types::{ExtensionMapping, UnsafeFixes};
+use ruff_linter::settings::types::UnsafeFixes;
 use ruff_linter::settings::{flags, LinterSettings};
 use ruff_linter::source_kind::{SourceError, SourceKind};
 use ruff_linter::{fs, IOError, SyntaxError};
@@ -179,11 +179,6 @@ impl AddAssign for FixMap {
     }
 }
 
-fn override_source_type(path: Option<&Path>, extension: &ExtensionMapping) -> Option<PySourceType> {
-    let ext = path?.extension()?.to_str()?;
-    extension.get(ext).map(PySourceType::from)
-}
-
 /// Lint the source code at the given `Path`.
 pub(crate) fn lint_path(
     path: &Path,
@@ -228,7 +223,7 @@ pub(crate) fn lint_path(
 
     debug!("Checking: {}", path.display());
 
-    let source_type = match override_source_type(Some(path), &settings.extension) {
+    let source_type = match settings.extension.get(path).map(PySourceType::from) {
         Some(source_type) => source_type,
         None => match SourceType::from(path) {
             SourceType::Toml(TomlSourceType::Pyproject) => {
@@ -398,15 +393,14 @@ pub(crate) fn lint_stdin(
     fix_mode: flags::FixMode,
 ) -> Result<Diagnostics> {
     // TODO(charlie): Support `pyproject.toml`.
-    let source_type = if let Some(source_type) =
-        override_source_type(path, &settings.linter.extension)
-    {
-        source_type
-    } else {
-        let SourceType::Python(source_type) = path.map(SourceType::from).unwrap_or_default() else {
-            return Ok(Diagnostics::default());
-        };
-        source_type
+    let source_type = match path.and_then(|path| settings.linter.extension.get(path)) {
+        None => match path.map(SourceType::from).unwrap_or_default() {
+            SourceType::Python(source_type) => source_type,
+            SourceType::Toml(_) => {
+                return Ok(Diagnostics::default());
+            }
+        },
+        Some(language) => PySourceType::from(language),
     };
 
     // Extract the sources from the file.

crates/ruff_cli/tests/format.rs

@@ -1468,3 +1468,73 @@ fn test_notebook_trailing_semicolon() {
     ----- stderr -----
     "###);
 }
+
+#[test]
+fn extension() -> Result<()> {
+    let tempdir = TempDir::new()?;
+
+    let ruff_toml = tempdir.path().join("ruff.toml");
+    fs::write(
+        &ruff_toml,
+        r#"
+include = ["*.ipy"]
+"#,
+    )?;
+
+    fs::write(
+        tempdir.path().join("main.ipy"),
+        r#"
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ad6f36d9-4b7d-4562-8d00-f15a0f1fbb6d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "x=1"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.0"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
+"#,
+    )?;
+
+    assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME))
+        .current_dir(tempdir.path())
+        .arg("format")
+        .arg("--no-cache")
+        .args(["--config", &ruff_toml.file_name().unwrap().to_string_lossy()])
+        .args(["--extension", "ipy:ipynb"])
+        .arg("."), @r###"
+    success: true
+    exit_code: 0
+    ----- stdout -----
+    1 file reformatted
+
+    ----- stderr -----
+    "###);
+    Ok(())
+}

crates/ruff_cli/tests/lint.rs

@@ -436,3 +436,75 @@ ignore = ["D203", "D212"]
     "###);
     Ok(())
 }
+
+#[test]
+fn extension() -> Result<()> {
+    let tempdir = TempDir::new()?;
+
+    let ruff_toml = tempdir.path().join("ruff.toml");
+    fs::write(
+        &ruff_toml,
+        r#"
+include = ["*.ipy"]
+"#,
+    )?;
+
+    fs::write(
+        tempdir.path().join("main.ipy"),
+        r#"
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ad6f36d9-4b7d-4562-8d00-f15a0f1fbb6d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.0"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
+"#,
+    )?;
+
+    assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME))
+        .current_dir(tempdir.path())
+        .arg("check")
+        .args(STDIN_BASE_OPTIONS)
+        .args(["--config", &ruff_toml.file_name().unwrap().to_string_lossy()])
+        .args(["--extension", "ipy:ipynb"])
+        .arg("."), @r###"
+    success: false
+    exit_code: 1
+    ----- stdout -----
+    main.ipy:cell 1:1:8: F401 [*] `os` imported but unused
+    Found 1 error.
+    [*] 1 fixable with the `--fix` option.
+
+    ----- stderr -----
+    "###);
+    Ok(())
+}

crates/ruff_cli/tests/show_settings.rs

@@ -0,0 +1,29 @@
+use insta_cmd::{assert_cmd_snapshot, get_cargo_bin};
+use std::path::Path;
+use std::process::Command;
+
+const BIN_NAME: &str = "ruff";
+
+#[cfg(not(target_os = "windows"))]
+const TEST_FILTERS: &[(&str, &str)] = &[
+    ("\"[^\\*\"]*/pyproject.toml", "\"[BASEPATH]/pyproject.toml"),
+    ("\".*/crates", "\"[BASEPATH]/crates"),
+    ("\".*/\\.ruff_cache", "\"[BASEPATH]/.ruff_cache"),
+    ("\".*/ruff\"", "\"[BASEPATH]\""),
+];
+#[cfg(target_os = "windows")]
+const TEST_FILTERS: &[(&str, &str)] = &[
+    (r#""[^\*"]*\\pyproject.toml"#, "\"[BASEPATH]/pyproject.toml"),
+    (r#"".*\\crates"#, "\"[BASEPATH]/crates"),
+    (r#"".*\\\.ruff_cache"#, "\"[BASEPATH]/.ruff_cache"),
+    (r#"".*\\ruff""#, "\"[BASEPATH]\""),
+    (r#"\\+(\w\w|\s|")"#, "/$1"),
+];
+
+#[test]
+fn display_default_settings() {
+    insta::with_settings!({ filters => TEST_FILTERS.to_vec() }, {
+        assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME))
+            .args(["check", "--show-settings", "unformatted.py"]).current_dir(Path::new("./resources/test/fixtures")));
+    });
+}

crates/ruff_cli/tests/snapshots/show_settings__display_default_settings.snap

@@ -0,0 +1,368 @@
+---
+source: crates/ruff_cli/tests/show_settings.rs
+info:
+  program: ruff
+  args:
+    - check
+    - "--show-settings"
+    - unformatted.py
+---
+success: true
+exit_code: 0
+----- stdout -----
+Resolved settings for: "[BASEPATH]/crates/ruff_cli/resources/test/fixtures/unformatted.py"
+Settings path: "[BASEPATH]/pyproject.toml"
+
+# General Settings
+cache_dir = "[BASEPATH]/.ruff_cache"
+fix = false
+fix_only = false
+output_format = text
+show_fixes = false
+show_source = false
+unsafe_fixes = hint
+
+# File Resolver Settings
+file_resolver.exclude = [
+	".bzr",
+	".direnv",
+	".eggs",
+	".git",
+	".git-rewrite",
+	".hg",
+	".ipynb_checkpoints",
+	".mypy_cache",
+	".nox",
+	".pants.d",
+	".pyenv",
+	".pytest_cache",
+	".pytype",
+	".ruff_cache",
+	".svn",
+	".tox",
+	".venv",
+	".vscode",
+	"__pypackages__",
+	"_build",
+	"buck-out",
+	"build",
+	"dist",
+	"node_modules",
+	"site-packages",
+	"venv",
+]
+file_resolver.extend_exclude = [
+	"crates/ruff_linter/resources/",
+	"crates/ruff_python_formatter/resources/",
+]
+file_resolver.force_exclude = false
+file_resolver.include = [
+	"*.py",
+	"*.pyi",
+	"**/pyproject.toml",
+]
+file_resolver.extend_include = []
+file_resolver.respect_gitignore = true
+file_resolver.project_root = "[BASEPATH]"
+
+# Linter Settings
+linter.exclude = []
+linter.project_root = "[BASEPATH]"
+linter.rules.enabled = [
+	MultipleImportsOnOneLine,
+	ModuleImportNotAtTopOfFile,
+	MultipleStatementsOnOneLineColon,
+	MultipleStatementsOnOneLineSemicolon,
+	UselessSemicolon,
+	NoneComparison,
+	TrueFalseComparison,
+	NotInTest,
+	NotIsTest,
+	TypeComparison,
+	BareExcept,
+	LambdaAssignment,
+	AmbiguousVariableName,
+	AmbiguousClassName,
+	AmbiguousFunctionName,
+	IOError,
+	SyntaxError,
+	UnusedImport,
+	ImportShadowedByLoopVar,
+	UndefinedLocalWithImportStar,
+	LateFutureImport,
+	UndefinedLocalWithImportStarUsage,
+	UndefinedLocalWithNestedImportStarUsage,
+	FutureFeatureNotDefined,
+	PercentFormatInvalidFormat,
+	PercentFormatExpectedMapping,
+	PercentFormatExpectedSequence,
+	PercentFormatExtraNamedArguments,
+	PercentFormatMissingArgument,
+	PercentFormatMixedPositionalAndNamed,
+	PercentFormatPositionalCountMismatch,
+	PercentFormatStarRequiresSequence,
+	PercentFormatUnsupportedFormatCharacter,
+	StringDotFormatInvalidFormat,
+	StringDotFormatExtraNamedArguments,
+	StringDotFormatExtraPositionalArguments,
+	StringDotFormatMissingArguments,
+	StringDotFormatMixingAutomatic,
+	FStringMissingPlaceholders,
+	MultiValueRepeatedKeyLiteral,
+	MultiValueRepeatedKeyVariable,
+	ExpressionsInStarAssignment,
+	MultipleStarredExpressions,
+	AssertTuple,
+	IsLiteral,
+	InvalidPrintSyntax,
+	IfTuple,
+	BreakOutsideLoop,
+	ContinueOutsideLoop,
+	YieldOutsideFunction,
+	ReturnOutsideFunction,
+	DefaultExceptNotLast,
+	ForwardAnnotationSyntaxError,
+	RedefinedWhileUnused,
+	UndefinedName,
+	UndefinedExport,
+	UndefinedLocal,
+	UnusedVariable,
+	UnusedAnnotation,
+	RaiseNotImplemented,
+]
+linter.rules.should_fix = [
+	MultipleImportsOnOneLine,
+	ModuleImportNotAtTopOfFile,
+	MultipleStatementsOnOneLineColon,
+	MultipleStatementsOnOneLineSemicolon,
+	UselessSemicolon,
+	NoneComparison,
+	TrueFalseComparison,
+	NotInTest,
+	NotIsTest,
+	TypeComparison,
+	BareExcept,
+	LambdaAssignment,
+	AmbiguousVariableName,
+	AmbiguousClassName,
+	AmbiguousFunctionName,
+	IOError,
+	SyntaxError,
+	UnusedImport,
+	ImportShadowedByLoopVar,
+	UndefinedLocalWithImportStar,
+	LateFutureImport,
+	UndefinedLocalWithImportStarUsage,
+	UndefinedLocalWithNestedImportStarUsage,
+	FutureFeatureNotDefined,
+	PercentFormatInvalidFormat,
+	PercentFormatExpectedMapping,
+	PercentFormatExpectedSequence,
+	PercentFormatExtraNamedArguments,
+	PercentFormatMissingArgument,
+	PercentFormatMixedPositionalAndNamed,
+	PercentFormatPositionalCountMismatch,
+	PercentFormatStarRequiresSequence,
+	PercentFormatUnsupportedFormatCharacter,
+	StringDotFormatInvalidFormat,
+	StringDotFormatExtraNamedArguments,
+	StringDotFormatExtraPositionalArguments,
+	StringDotFormatMissingArguments,
+	StringDotFormatMixingAutomatic,
+	FStringMissingPlaceholders,
+	MultiValueRepeatedKeyLiteral,
+	MultiValueRepeatedKeyVariable,
+	ExpressionsInStarAssignment,
+	MultipleStarredExpressions,
+	AssertTuple,
+	IsLiteral,
+	InvalidPrintSyntax,
+	IfTuple,
+	BreakOutsideLoop,
+	ContinueOutsideLoop,
+	YieldOutsideFunction,
+	ReturnOutsideFunction,
+	DefaultExceptNotLast,
+	ForwardAnnotationSyntaxError,
+	RedefinedWhileUnused,
+	UndefinedName,
+	UndefinedExport,
+	UndefinedLocal,
+	UnusedVariable,
+	UnusedAnnotation,
+	RaiseNotImplemented,
+]
+linter.per_file_ignores = {}
+linter.safety_table.forced_safe = []
+linter.safety_table.forced_unsafe = []
+linter.target_version = Py37
+linter.preview = disabled
+linter.explicit_preview_rules = false
+linter.extension.mapping = {}
+linter.allowed_confusables = []
+linter.builtins = []
+linter.dummy_variable_rgx = ^(_+|(_+[a-zA-Z0-9_]*[a-zA-Z0-9]+?))$
+linter.external = []
+linter.ignore_init_module_imports = false
+linter.logger_objects = []
+linter.namespace_packages = []
+linter.src = ["[BASEPATH]"]
+linter.tab_size = 4
+linter.line_length = 88
+linter.task_tags = [
+	TODO,
+	FIXME,
+	XXX,
+]
+linter.typing_modules = []
+
+# Linter Plugins
+linter.flake8_annotations.mypy_init_return = false
+linter.flake8_annotations.suppress_dummy_args = false
+linter.flake8_annotations.suppress_none_returning = false
+linter.flake8_annotations.allow_star_arg_any = false
+linter.flake8_annotations.ignore_fully_untyped = false
+linter.flake8_bandit.hardcoded_tmp_directory = [
+	/tmp,
+	/var/tmp,
+	/dev/shm,
+]
+linter.flake8_bandit.check_typed_exception = false
+linter.flake8_bugbear.extend_immutable_calls = []
+linter.flake8_builtins.builtins_ignorelist = []
+linter.flake8_comprehensions.allow_dict_calls_with_keyword_arguments = false
+linter.flake8_copyright.notice_rgx = (?i)Copyright\s+(\(C\)\s+)?\d{4}(-\d{4})*
+linter.flake8_copyright.author = none
+linter.flake8_copyright.min_file_size = 0
+linter.flake8_errmsg.max_string_length = 0
+linter.flake8_gettext.functions_names = [
+	_,
+	gettext,
+	ngettext,
+]
+linter.flake8_implicit_str_concat.allow_multiline = true
+linter.flake8_import_conventions.aliases = {"matplotlib": "mpl", "matplotlib.pyplot": "plt", "pandas": "pd", "seaborn": "sns", "tensorflow": "tf", "networkx": "nx", "plotly.express": "px", "polars": "pl", "numpy": "np", "panel": "pn", "pyarrow": "pa", "altair": "alt", "tkinter": "tk", "holoviews": "hv"}
+linter.flake8_import_conventions.banned_aliases = {}
+linter.flake8_import_conventions.banned_from = []
+linter.flake8_pytest_style.fixture_parentheses = true
+linter.flake8_pytest_style.parametrize_names_type = tuple
+linter.flake8_pytest_style.parametrize_values_type = list
+linter.flake8_pytest_style.parametrize_values_row_type = tuple
+linter.flake8_pytest_style.raises_require_match_for = [
+	BaseException,
+	Exception,
+	ValueError,
+	OSError,
+	IOError,
+	EnvironmentError,
+	socket.error,
+]
+linter.flake8_pytest_style.raises_extend_require_match_for = []
+linter.flake8_pytest_style.mark_parentheses = true
+linter.flake8_quotes.inline_quotes = double
+linter.flake8_quotes.multiline_quotes = double
+linter.flake8_quotes.docstring_quotes = double
+linter.flake8_quotes.avoid_escape = true
+linter.flake8_self.ignore_names = [
+	_make,
+	_asdict,
+	_replace,
+	_fields,
+	_field_defaults,
+	_name_,
+	_value_,
+]
+linter.flake8_tidy_imports.ban_relative_imports = "parents"
+linter.flake8_tidy_imports.banned_api = {}
+linter.flake8_tidy_imports.banned_module_level_imports = []
+linter.flake8_type_checking.strict = false
+linter.flake8_type_checking.exempt_modules = [
+	typing,
+	typing_extensions,
+]
+linter.flake8_type_checking.runtime_required_base_classes = []
+linter.flake8_type_checking.runtime_required_decorators = []
+linter.flake8_type_checking.quote_annotations = false
+linter.flake8_unused_arguments.ignore_variadic_names = false
+linter.isort.required_imports = []
+linter.isort.combine_as_imports = false
+linter.isort.force_single_line = false
+linter.isort.force_sort_within_sections = false
+linter.isort.detect_same_package = true
+linter.isort.case_sensitive = false
+linter.isort.force_wrap_aliases = false
+linter.isort.force_to_top = []
+linter.isort.known_modules = {}
+linter.isort.order_by_type = true
+linter.isort.relative_imports_order = furthest_to_closest
+linter.isort.single_line_exclusions = []
+linter.isort.split_on_trailing_comma = true
+linter.isort.classes = []
+linter.isort.constants = []
+linter.isort.variables = []
+linter.isort.no_lines_before = []
+linter.isort.lines_after_imports = -1
+linter.isort.lines_between_types = 0
+linter.isort.forced_separate = []
+linter.isort.section_order = [
+	known { type = future },
+	known { type = standard_library },
+	known { type = third_party },
+	known { type = first_party },
+	known { type = local_folder },
+]
+linter.isort.no_sections = false
+linter.isort.from_first = false
+linter.isort.length_sort = false
+linter.isort.length_sort_straight = false
+linter.mccabe.max_complexity = 10
+linter.pep8_naming.ignore_names = [
+	setUp,
+	tearDown,
+	setUpClass,
+	tearDownClass,
+	setUpModule,
+	tearDownModule,
+	asyncSetUp,
+	asyncTearDown,
+	setUpTestData,
+	failureException,
+	longMessage,
+	maxDiff,
+]
+linter.pep8_naming.classmethod_decorators = []
+linter.pep8_naming.staticmethod_decorators = []
+linter.pycodestyle.max_line_length = 88
+linter.pycodestyle.max_doc_length = none
+linter.pycodestyle.ignore_overlong_task_comments = false
+linter.pyflakes.extend_generics = []
+linter.pylint.allow_magic_value_types = [
+	str,
+	bytes,
+]
+linter.pylint.allow_dunder_method_names = []
+linter.pylint.max_args = 5
+linter.pylint.max_positional_args = 5
+linter.pylint.max_returns = 6
+linter.pylint.max_bool_expr = 5
+linter.pylint.max_branches = 12
+linter.pylint.max_statements = 50
+linter.pylint.max_public_methods = 20
+linter.pylint.max_locals = 15
+linter.pyupgrade.keep_runtime_typing = false
+
+# Formatter Settings
+formatter.exclude = []
+formatter.target_version = Py37
+formatter.preview = disabled
+formatter.line_width = 88
+formatter.line_ending = auto
+formatter.indent_style = space
+formatter.indent_width = 4
+formatter.quote_style = double
+formatter.magic_trailing_comma = respect
+formatter.docstring_code_format = disabled
+formatter.docstring_code_line_width = dynamic
+
+----- stderr -----
+

crates/ruff_dev/src/format_dev.rs

@@ -27,7 +27,7 @@ use tracing_subscriber::layer::SubscriberExt;
 use tracing_subscriber::util::SubscriberInitExt;
 use tracing_subscriber::EnvFilter;
 
-use ruff_cli::args::{FormatCommand, LogLevelArgs};
+use ruff_cli::args::{CliOverrides, FormatArguments, FormatCommand, LogLevelArgs};
 use ruff_cli::resolve::resolve;
 use ruff_formatter::{FormatError, LineWidth, PrintError};
 use ruff_linter::logging::LogLevel;
@@ -38,24 +38,24 @@ use ruff_python_formatter::{
 use ruff_python_parser::ParseError;
 use ruff_workspace::resolver::{python_files_in_path, PyprojectConfig, ResolvedFile, Resolver};
 
-/// Find files that ruff would check so we can format them. Adapted from `ruff_cli`.
-#[allow(clippy::type_complexity)]
-fn ruff_check_paths(
-    dirs: &[PathBuf],
-) -> anyhow::Result<(
-    Vec<Result<ResolvedFile, ignore::Error>>,
-    Resolver,
-    PyprojectConfig,
-)> {
+fn parse_cli(dirs: &[PathBuf]) -> anyhow::Result<(FormatArguments, CliOverrides)> {
     let args_matches = FormatCommand::command()
         .no_binary_name(true)
         .get_matches_from(dirs);
     let arguments: FormatCommand = FormatCommand::from_arg_matches(&args_matches)?;
     let (cli, overrides) = arguments.partition();
+    Ok((cli, overrides))
+}
+
+/// Find the [`PyprojectConfig`] to use for formatting.
+fn find_pyproject_config(
+    cli: &FormatArguments,
+    overrides: &CliOverrides,
+) -> anyhow::Result<PyprojectConfig> {
     let mut pyproject_config = resolve(
         cli.isolated,
         cli.config.as_deref(),
-        &overrides,
+        overrides,
         cli.stdin_filename.as_deref(),
     )?;
     // We don't want to format pyproject.toml
@@ -64,11 +64,18 @@ fn ruff_check_paths(
         FilePattern::Builtin("*.pyi"),
     ])
     .unwrap();
-    let (paths, resolver) = python_files_in_path(&cli.files, &pyproject_config, &overrides)?;
-    if paths.is_empty() {
-        bail!("no python files in {:?}", dirs)
-    }
-    Ok((paths, resolver, pyproject_config))
+    Ok(pyproject_config)
+}
+
+/// Find files that ruff would check so we can format them. Adapted from `ruff_cli`.
+#[allow(clippy::type_complexity)]
+fn ruff_check_paths<'a>(
+    pyproject_config: &'a PyprojectConfig,
+    cli: &FormatArguments,
+    overrides: &CliOverrides,
+) -> anyhow::Result<(Vec<Result<ResolvedFile, ignore::Error>>, Resolver<'a>)> {
+    let (paths, resolver) = python_files_in_path(&cli.files, pyproject_config, overrides)?;
+    Ok((paths, resolver))
 }
 
 /// Collects statistics over the formatted files to compute the Jaccard index or the similarity
@@ -216,6 +223,7 @@ pub(crate) struct Args {
     #[arg(long)]
     pub(crate) files_with_errors: Option<u32>,
     #[clap(flatten)]
+    #[allow(clippy::struct_field_names)]
     pub(crate) log_level_args: LogLevelArgs,
 }
 
@@ -451,11 +459,17 @@ fn format_dev_project(
         files[0].display()
     );
 
-    // TODO(konstin): black excludes
+    // TODO(konstin): Respect black's excludes.
 
     // Find files to check (or in this case, format twice). Adapted from ruff_cli
     // First argument is ignored
-    let (paths, resolver, pyproject_config) = ruff_check_paths(files)?;
+    let (cli, overrides) = parse_cli(files)?;
+    let pyproject_config = find_pyproject_config(&cli, &overrides)?;
+    let (paths, resolver) = ruff_check_paths(&pyproject_config, &cli, &overrides)?;
+
+    if paths.is_empty() {
+        bail!("No Python files found under the given path(s)");
+    }
 
     let results = {
         let pb_span =
@@ -468,14 +482,7 @@ fn format_dev_project(
         #[cfg(feature = "singlethreaded")]
         let iter = { paths.into_iter() };
         iter.map(|path| {
-            let result = format_dir_entry(
-                path,
-                stability_check,
-                write,
-                &black_options,
-                &resolver,
-                &pyproject_config,
-            );
+            let result = format_dir_entry(path, stability_check, write, &black_options, &resolver);
             pb_span.pb_inc(1);
             result
         })
@@ -525,14 +532,13 @@ fn format_dev_project(
     })
 }
 
-/// Error handling in between walkdir and `format_dev_file`
+/// Error handling in between walkdir and `format_dev_file`.
 fn format_dir_entry(
     resolved_file: Result<ResolvedFile, ignore::Error>,
     stability_check: bool,
     write: bool,
     options: &BlackOptions,
     resolver: &Resolver,
-    pyproject_config: &PyprojectConfig,
 ) -> anyhow::Result<(Result<Statistics, CheckFileError>, PathBuf), Error> {
     let resolved_file = resolved_file.context("Iterating the files in the repository failed")?;
     // For some reason it does not filter in the beginning
@@ -543,7 +549,7 @@ fn format_dir_entry(
     let path = resolved_file.into_path();
     let mut options = options.to_py_format_options(&path);
 
-    let settings = resolver.resolve(&path, pyproject_config);
+    let settings = resolver.resolve(&path);
     // That's a bad way of doing this but it's not worth doing something better for format_dev
     if settings.formatter.line_width != LineWidth::default() {
         options = options.with_line_width(settings.formatter.line_width);

crates/ruff_formatter/src/lib.rs

@@ -35,6 +35,7 @@ mod source_code;
 use crate::formatter::Formatter;
 use crate::group_id::UniqueGroupIdBuilder;
 use crate::prelude::TagKind;
+use std::fmt;
 use std::fmt::{Debug, Display};
 use std::marker::PhantomData;
 use std::num::{NonZeroU16, NonZeroU8, TryFromIntError};
@@ -113,6 +114,12 @@ impl Default for IndentWidth {
     }
 }
 
+impl Display for IndentWidth {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        Display::fmt(&self.0, f)
+    }
+}
+
 impl TryFrom<u8> for IndentWidth {
     type Error = TryFromIntError;
 
@@ -146,6 +153,12 @@ impl Default for LineWidth {
     }
 }
 
+impl Display for LineWidth {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        Display::fmt(&self.0, f)
+    }
+}
+
 impl TryFrom<u16> for LineWidth {
     type Error = TryFromIntError;
 

crates/ruff_formatter/src/printer/mod.rs

@@ -1472,6 +1472,11 @@ impl<'a, 'print> FitsMeasurer<'a, 'print> {
     }
 
     fn fits_text(&mut self, text: Text, args: PrintElementArgs) -> Fits {
+        fn exceeds_width(fits: &FitsMeasurer, args: PrintElementArgs) -> bool {
+            fits.state.line_width > fits.options().line_width.into()
+                && !args.measure_mode().allows_text_overflow()
+        }
+
         let indent = std::mem::take(&mut self.state.pending_indent);
         self.state.line_width +=
             u32::from(indent.level()) * self.options().indent_width() + u32::from(indent.align());
@@ -1493,7 +1498,13 @@ impl<'a, 'print> FitsMeasurer<'a, 'print> {
                                     return Fits::No;
                                 }
                                 match args.measure_mode() {
-                                    MeasureMode::FirstLine => return Fits::Yes,
+                                    MeasureMode::FirstLine => {
+                                        return if exceeds_width(self, args) {
+                                            Fits::No
+                                        } else {
+                                            Fits::Yes
+                                        };
+                                    }
                                     MeasureMode::AllLines
                                     | MeasureMode::AllLinesAllowTextOverflow => {
                                         self.state.line_width = 0;
@@ -1511,9 +1522,7 @@ impl<'a, 'print> FitsMeasurer<'a, 'print> {
             }
         }
 
-        if self.state.line_width > self.options().line_width.into()
-            && !args.measure_mode().allows_text_overflow()
-        {
+        if exceeds_width(self, args) {
             return Fits::No;
         }
 

crates/ruff_linter/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ruff_linter"
-version = "0.1.11"
+version = "0.1.13"
 publish = false
 authors = { workspace = true }
 edition = { workspace = true }
@@ -85,8 +85,6 @@ tempfile = { workspace = true }
 [features]
 default = []
 schemars = ["dep:schemars"]
-# Enables the UnreachableCode rule
-unreachable-code = []
 
 [lints]
 workspace = true

crates/ruff_linter/resources/test/fixtures/flake8_boolean_trap/FBT.py

@@ -71,6 +71,8 @@ foo.is_(True)
 bar.is_not(False)
 next(iter([]), False)
 sa.func.coalesce(tbl.c.valid, False)
+setVisible(True)
+set_visible(True)
 
 
 class Registry:
@@ -114,3 +116,6 @@ from typing import override
 @override
 def func(x: bool):
     pass
+
+
+settings(True)

crates/ruff_linter/resources/test/fixtures/flake8_bugbear/B033.py

@@ -2,10 +2,28 @@
 # Errors.
 ###
 incorrect_set = {"value1", 23, 5, "value1"}
+incorrect_set = {1, 1, 2}
+incorrect_set_multiline = {
+    "value1",
+    23,
+    5,
+    "value1",
+    # B033
+}
 incorrect_set = {1, 1}
+incorrect_set = {1, 1,}
+incorrect_set = {0, 1, 1,}
+incorrect_set = {0, 1, 1}
+incorrect_set = {
+    0,
+    1,
+    1,
+}
 
 ###
 # Non-errors.
 ###
 correct_set = {"value1", 23, 5}
 correct_set = {5, "5"}
+correct_set = {5}
+correct_set = {}

crates/ruff_linter/resources/test/fixtures/flake8_builtins/A003.py

@@ -8,46 +8,14 @@ class MyClass:
         self.id = 10
         self.dir = "."
 
-    def str(self):
-        pass
-
-
-from typing import TypedDict
-
-
-class MyClass(TypedDict):
-    id: int
-
-
-from threading import Event
-
-
-class CustomEvent(Event):
-    def set(self) -> None:
-        ...
-
-    def str(self) -> None:
-        ...
-
-
-from logging import Filter, LogRecord
-
-
-class CustomFilter(Filter):
-    def filter(self, record: LogRecord) -> bool:
-        ...
-
-    def str(self) -> None:
-        ...
-
-
-from typing_extensions import override
-
-
-class MyClass:
-    @override
-    def str(self):
-        pass
-
     def int(self):
         pass
+
+    def str(self):
+        pass
+
+    def method_usage(self) -> str:
+        pass
+
+    def attribute_usage(self) -> id:
+        pass

crates/ruff_linter/resources/test/fixtures/flake8_pyi/PYI053.py

@@ -1,3 +1,9 @@
+import warnings
+import typing_extensions
+from collections.abc import Callable
+from warnings import deprecated
+
+
 def f1(x: str = "50 character stringggggggggggggggggggggggggggggggg") -> None:
     ...
 
@@ -45,3 +51,24 @@ class Demo:
 
 def func() -> None:
     """Docstrings are excluded from this rule. Some padding."""
+
+
+@warnings.deprecated("Veeeeeeeeeeeeeeeeeeeeeeery long deprecation message, but that's okay")
+def deprecated_function() -> None: ...
+
+
+@typing_extensions.deprecated("Another loooooooooooooooooooooong deprecation message, it's still okay")
+def another_deprecated_function() -> None: ...
+
+
+@deprecated("A third loooooooooooooooooooooooooooooong deprecation message")
+def a_third_deprecated_function() -> None: ...
+
+
+def not_warnings_dot_deprecated(
+    msg: str
+) -> Callable[[Callable[[], None]], Callable[[], None]]: ...
+
+
+@not_warnings_dot_deprecated("Not warnings.deprecated, so this one *should* lead to PYI053 in a stub!")
+def not_a_deprecated_function() -> None: ...

crates/ruff_linter/resources/test/fixtures/flake8_pyi/PYI053.pyi

@@ -1,3 +1,7 @@
+import warnings
+import typing_extensions
+from typing_extensions import deprecated
+
 def f1(x: str = "50 character stringggggggggggggggggggggggggggggggg") -> None: ...  # OK
 def f2(
     x: str = "51 character stringgggggggggggggggggggggggggggggggg",  # Error: PYI053
@@ -38,3 +42,25 @@ class Demo:
 
 def func() -> None:
     """Docstrings are excluded from this rule. Some padding."""  # OK
+
+@warnings.deprecated(
+    "Veeeeeeeeeeeeeeeeeeeeeeery long deprecation message, but that's okay"  # OK
+)
+def deprecated_function() -> None: ...
+
+@typing_extensions.deprecated(
+    "Another loooooooooooooooooooooong deprecation message, it's still okay"  # OK
+)
+def another_deprecated_function() -> None: ...
+
+@deprecated("A third loooooooooooooooooooooooooooooong deprecation message")  # OK
+def a_third_deprecated_function() -> None: ...
+
+def not_warnings_dot_deprecated(
+    msg: str
+) -> Callable[[Callable[[], None]], Callable[[], None]]: ...
+
+@not_warnings_dot_deprecated(
+    "Not warnings.deprecated, so this one *should* lead to PYI053 in a stub!"  # Error: PYI053
+)
+def not_a_deprecated_function() -> None: ...

crates/ruff_linter/resources/test/fixtures/flake8_simplify/SIM113.py

@@ -0,0 +1,195 @@
+def func():
+    # SIM113
+    idx = 0
+    for x in range(5):
+        g(x, idx)
+        idx += 1
+        h(x)
+
+
+def func():
+    # SIM113
+    sum = 0
+    idx = 0
+    for x in range(5):
+        if g(x):
+            break
+        idx += 1
+        sum += h(x, idx)
+
+
+def func():
+    # SIM113
+    idx = 0
+    for x, y in zip(range(5), range(5)):
+        g(x)
+        h(x, y)
+        idx += 1
+
+
+def func():
+    # SIM113
+    idx = 0
+    sum = 0
+    for x in range(5):
+        sum += h(x, idx)
+        idx += 1
+
+
+def func():
+    # SIM113
+    sum, idx = 0, 0
+    for x in range(5):
+        g(x, idx)
+        idx += 1
+        h(x)
+
+
+def func():
+    # OK (index doesn't start at 0
+    idx = 10
+    for x in range(5):
+        g(x, idx)
+        idx += 1
+        h(x)
+
+
+def func():
+    # OK (incremented by more than 1)
+    idx = 0
+    for x in range(5):
+        g(x, idx)
+        idx += 2
+        h(x)
+
+
+def func():
+    # OK (incremented in `if`)
+    idx = 0
+    for x in range(5):
+        if g(x):
+            idx += 1
+        h(x)
+
+
+def func():
+    # OK (`continue` in match-case)
+    idx = 0
+    for x in range(5):
+        match g(x):
+            case 1:
+                h(x)
+            case 2:
+                continue
+            case _:
+                h(idx)
+        idx += 1
+
+
+def func():
+    # OK (`continue` inside `with` clause)
+    idx = 0
+    for x in range(5):
+        with context as c:
+            if g(x):
+                continue
+            h(x, idx, c)
+        idx += 1
+
+
+def func():
+    # OK (incremented in `try` block)
+    idx = 0
+    for x in range(5):
+        try:
+            g(x, idx)
+        except:
+            h(x)
+            continue
+        idx += 1
+
+
+def func(idx: 0):
+    # OK (index is an argument)
+    for x in range(5):
+        g(x, idx)
+        idx += 1
+
+
+def func(x: int):
+    # OK (index _may_ be non-zero)
+    if x > 0:
+        idx = 1
+    else:
+        idx = 0
+    for x in range(5):
+        g(x, idx)
+        idx += 1
+        h(x)
+
+
+def func():
+    # OK
+    idx = 0
+    for x in range(5):
+        g(x, idx)
+        idx += 1
+        idx += 1
+        h(x)
+
+
+def func():
+    # OK
+    idx = 0
+    for x in range(5):
+        g(x, idx)
+        idx += 1
+        if idx > 10:
+            idx *= 2
+        h(x)
+
+
+def func():
+    # OK (index used after loop)
+    idx = 0
+    for x in range(5):
+        g(x, idx)
+        idx += 1
+        h(x)
+    print(idx)
+
+
+def func():
+    # OK (index within nested loop)
+    idx = 0
+    for x in range(5):
+        for y in range(5):
+            g(x, idx)
+            idx += 1
+
+
+def func():
+    # OK (index used within inner)
+    idx = 0
+
+    def inner():
+        print(idx)
+
+    for x in range(5):
+        for y in range(5):
+            g(x, idx)
+            idx += 1
+
+
+def func():
+    # OK (index used as nonlocal inner)
+    idx = 0
+
+    def inner():
+        nonlocal idx
+        idx = 3
+
+    for x in range(5):
+        for y in range(5):
+            g(x, idx)
+            idx += 1

crates/ruff_linter/resources/test/fixtures/flake8_simplify/SIM222.py

@@ -160,3 +160,10 @@ def secondToTime(s0: int) -> (int, int, int) or str:
 
 def secondToTime(s0: int) -> ((int, int, int) or str):
     m, s = divmod(s0, 60)
+
+
+# Regression test for: https://github.com/astral-sh/ruff/issues/9479
+print(f"{a}{b}" or "bar")
+print(f"{a}{''}" or "bar")
+print(f"{''}{''}" or "bar")
+print(f"{1}{''}" or "bar")

crates/ruff_linter/resources/test/fixtures/flake8_simplify/SIM223.py

@@ -147,3 +147,9 @@ if (a and [] and False and []) == (a and []):  # SIM223
 
 if f(a and [] and False and []):  # SIM223
     pass
+
+# Regression test for: https://github.com/astral-sh/ruff/issues/9479
+print(f"{a}{b}" and "bar")
+print(f"{a}{''}" and "bar")
+print(f"{''}{''}" and "bar")
+print(f"{1}{''}" and "bar")

crates/ruff_linter/resources/test/fixtures/flake8_simplify/SIM911.py

@@ -0,0 +1,23 @@
+def foo(d: dict[str, str]) -> None:
+    for k, v in zip(d.keys(), d.values()):  # SIM911
+        ...
+
+    for k, v in zip(d.keys(), d.values(), strict=True):  # SIM911
+        ...
+
+    for k, v in zip(d.keys(), d.values(), struct=True):  # OK
+        ...
+
+
+d1 = d2 = {}
+
+for k, v in zip(d1.keys(), d2.values()):  # OK
+    ...
+
+for k, v in zip(d1.items(), d2.values()):  # OK
+    ...
+
+for k, v in zip(d2.keys(), d2.values()):  # SIM911
+    ...
+
+items = zip(x.keys(), x.values())  # OK

crates/ruff_linter/resources/test/fixtures/pandas_vet/PD002.py

@@ -31,3 +31,6 @@ import torch
 torch.m.ReLU(inplace=True)  # safe because this isn't a pandas call
 
 (x.drop(["a"], axis=1, inplace=True))
+
+# This method doesn't take exist in Pandas, so ignore it.
+x.rotate_z(45, inplace=True)

crates/ruff_linter/resources/test/fixtures/pydocstyle/D417.py

@@ -150,3 +150,21 @@ class Test:
         Args:
             arg1: some description of arg
         """
+
+
+def select_data(
+    query: str,
+    args: tuple,
+    database: str,
+    auto_save: bool,
+) -> None:
+    """This function has an argument `args`, which shouldn't be mistaken for a section.
+
+    Args:
+        query:
+            Query template.
+        args:
+            A list of arguments.
+        database:
+            Which database to connect to ("origin" or "destination").
+    """

crates/ruff_linter/resources/test/fixtures/pydocstyle/sections.py

@@ -536,9 +536,29 @@ def non_empty_blank_line_before_section():  # noqa: D416
     """Toggle the gizmo.
 
     The function's description.
-    
+
     Returns
     -------
     A value of some sort.
 
     """
+
+
+def lowercase_sub_section_header():
+    """Below, `returns:` should _not_ be considered a section header.
+
+    Args:
+        Here's a note.
+
+        returns:
+    """
+
+
+def titlecase_sub_section_header():
+    """Below, `Returns:` should be considered a section header.
+
+    Args:
+        Here's a note.
+
+        Returns:
+    """

crates/ruff_linter/resources/test/fixtures/pyflakes/F811_27.py

@@ -0,0 +1,6 @@
+import os
+
+x = 1
+
+if x > 0:
+    import os

crates/ruff_linter/resources/test/fixtures/pylint/unnecessary_dunder_call.py

@@ -24,6 +24,12 @@ class Thing:
         super().__init__()  # OK
         super().__class__(stuff=(1, 2, 3))  # OK
 
+    def __getattribute__(self, item):
+        return object.__getattribute__(self, item)  # OK
+
+    def do_thing(self, item):
+        return object.__getattribute__(self, item)  # PLC2801
+
 
 blah = lambda: {"a": 1}.__delitem__("a")  # OK
 

crates/ruff_linter/resources/test/fixtures/pyupgrade/UP035.py

@@ -91,3 +91,12 @@ from typing_extensions import dataclass_transform
 
 # UP035
 from backports.strenum import StrEnum
+
+# UP035
+from typing_extensions import override
+
+# UP035
+from typing_extensions import Buffer
+
+# UP035
+from typing_extensions import get_original_bases

crates/ruff_linter/resources/test/fixtures/ruff/RUF011.py

@@ -10,6 +10,8 @@ constant = 5
 {value.attribute: value.upper() for value in data for constant in data}
 {constant[value]: value.upper() for value in data for constant in data}
 {value[constant]: value.upper() for value in data for constant in data}
+{local_id: token for token in tokens if (local_id := _extract_local_id(token)) is not None}
+{key: kwargs.get(key) for key in kwargs.keys() if not params.get(key)}
 
 # Errors
 {"key": value.upper() for value in data}
@@ -20,3 +22,5 @@ constant = 5
 {constant + constant: value.upper() for value in data}
 {constant.attribute: value.upper() for value in data}
 {constant[0]: value.upper() for value in data}
+{tokens: token for token in tokens}
+

crates/ruff_linter/resources/test/fixtures/ruff/RUF013_0.py

@@ -1,5 +1,5 @@
 import typing
-from typing import Annotated, Any, Literal, Optional, Tuple, Union
+from typing import Annotated, Any, Literal, Optional, Tuple, Union, Hashable
 
 
 def f(arg: int):
@@ -257,3 +257,13 @@ from custom_typing import MaybeInt
 
 def f(arg: MaybeInt = None):
     pass
+
+
+# Hashable
+
+def f(arg: Hashable = None):  # OK
+    pass
+
+
+def f(arg: Hashable | int = None):  # OK
+    pass

crates/ruff_linter/resources/test/fixtures/ruff/RUF014.py

@@ -1,185 +0,0 @@
-def after_return():
-    return "reachable"
-    return "unreachable"
-
-async def also_works_on_async_functions():
-    return "reachable"
-    return "unreachable"
-
-def if_always_true():
-    if True:
-        return "reachable"
-    return "unreachable"
-
-def if_always_false():
-    if False:
-        return "unreachable"
-    return "reachable"
-
-def if_elif_always_false():
-    if False:
-        return "unreachable"
-    elif False:
-        return "also unreachable"
-    return "reachable"
-
-def if_elif_always_true():
-    if False:
-        return "unreachable"
-    elif True:
-        return "reachable"
-    return "also unreachable"
-
-def ends_with_if():
-    if False:
-        return "unreachable"
-    else:
-        return "reachable"
-
-def infinite_loop():
-    while True:
-        continue
-    return "unreachable"
-
-'''  TODO: we could determine these, but we don't yet.
-def for_range_return():
-    for i in range(10):
-        if i == 5:
-            return "reachable"
-    return "unreachable"
-
-def for_range_else():
-    for i in range(111):
-        if i == 5:
-            return "reachable"
-    else:
-        return "unreachable"
-    return "also unreachable"
-
-def for_range_break():
-    for i in range(13):
-        return "reachable"
-    return "unreachable"
-
-def for_range_if_break():
-    for i in range(1110):
-        if True:
-            return "reachable"
-    return "unreachable"
-'''
-
-def match_wildcard(status):
-    match status:
-        case _:
-            return "reachable"
-    return "unreachable"
-
-def match_case_and_wildcard(status):
-    match status:
-        case 1:
-            return "reachable"
-        case _:
-            return "reachable"
-    return "unreachable"
-
-def raise_exception():
-    raise Exception
-    return "unreachable"
-
-def while_false():
-    while False:
-        return "unreachable"
-    return "reachable"
-
-def while_false_else():
-    while False:
-        return "unreachable"
-    else:
-        return "reachable"
-
-def while_false_else_return():
-    while False:
-        return "unreachable"
-    else:
-        return "reachable"
-    return "also unreachable"
-
-def while_true():
-    while True:
-        return "reachable"
-    return "unreachable"
-
-def while_true_else():
-    while True:
-        return "reachable"
-    else:
-        return "unreachable"
-
-def while_true_else_return():
-    while True:
-        return "reachable"
-    else:
-        return "unreachable"
-    return "also unreachable"
-
-def while_false_var_i():
-    i = 0
-    while False:
-        i += 1
-    return i
-
-def while_true_var_i():
-    i = 0
-    while True:
-        i += 1
-    return i
-
-def while_infinite():
-    while True:
-        pass
-    return "unreachable"
-
-def while_if_true():
-    while True:
-        if True:
-            return "reachable"
-    return "unreachable"
-
-# Test case found in the Bokeh repository that trigger a false positive.
-def bokeh1(self, obj: BytesRep) -> bytes:
-    data = obj["data"]
-
-    if isinstance(data, str):
-        return base64.b64decode(data)
-    elif isinstance(data, Buffer):
-        buffer = data
-    else:
-        id = data["id"]
-
-        if id in self._buffers:
-            buffer = self._buffers[id]
-        else:
-            self.error(f"can't resolve buffer '{id}'")
-
-    return buffer.data
-
-'''
-TODO: because `try` statements aren't handled this triggers a false positive as
-the last statement is reached, but the rules thinks it isn't (it doesn't
-see/process the break statement).
-
-# Test case found in the Bokeh repository that trigger a false positive.
-def bokeh2(self, host: str = DEFAULT_HOST, port: int = DEFAULT_PORT) -> None:
-    self.stop_serving = False
-    while True:
-        try:
-            self.server = HTTPServer((host, port), HtmlOnlyHandler)
-            self.host = host
-            self.port = port
-            break
-        except OSError:
-            log.debug(f"port {port} is in use, trying to next one")
-            port += 1
-
-    self.thread = threading.Thread(target=self._run_web_server)
-'''

crates/ruff_linter/resources/test/fixtures/ruff/RUF021.py

@@ -0,0 +1,114 @@
+# See https://docs.python.org/3/reference/expressions.html#operator-precedence
+# for the official docs on operator precedence.
+#
+# Most importantly, `and` *always* takes precedence over `or`.
+#
+# `not` (the third boolean/logical operator) takes precedence over both,
+# but the rule there is easier to remember,
+# so we don't emit a diagnostic if a `not` expression is unparenthesized
+# as part of a chain.
+
+a, b, c = 1, 0, 2
+x = a or b and c  # RUF021: => `a or (b and c)`
+x = a or b and c  # looooooooooooooooooooooooooooooong comment but it won't prevent an autofix
+
+a, b, c = 0, 1, 2
+y = a and b or c  # RUF021: => `(a and b) or c`
+
+a, b, c, d = 1, 2, 0, 3
+if a or b or c and d:  # RUF021: => `a or b or (c and d)`
+    pass
+
+a, b, c, d = 0, 0, 2, 3
+
+if bool():
+    pass
+elif a or b and c or d:  # RUF021: => `a or (b and c) or d`
+    pass
+
+a, b, c, d = 0, 1, 0, 2
+while a and b or c and d:  # RUF021: => `(and b) or (c and d)`
+    pass
+
+b, c, d, e = 2, 3, 0, 4
+# RUF021: => `a or b or c or (d and e)`:
+z = [a for a in range(5) if a or b or c or d and e]
+
+a, b, c, d = 0, 1, 3, 0
+assert not a and b or c or d  # RUF021: => `(not a and b) or c or d`
+
+if (not a) and b or c or d:  # RUF021: => `((not a) and b) or c or d`
+    if (not a and b) or c or d:  # OK
+        pass
+
+if (
+    some_reasonably_long_condition
+    or some_other_reasonably_long_condition
+    and some_third_reasonably_long_condition
+    or some_fourth_reasonably_long_condition
+    and some_fifth_reasonably_long_condition
+    # a commment
+    and some_sixth_reasonably_long_condition
+    and some_seventh_reasonably_long_condition
+    # another comment
+    or some_eighth_reasonably_long_condition
+):
+    pass
+
+#############################################
+# If they're all the same operator, it's fine
+#############################################
+
+x = not a and c  # OK
+
+if a or b or c:  # OK
+    pass
+
+while a and b and c:  # OK
+    pass
+
+###########################################################
+# We don't consider `not` as part of a chain as problematic
+###########################################################
+
+x = not a or not b or not c  # OK
+
+#####################################
+# If they're parenthesized, it's fine
+#####################################
+
+a, b, c = 1, 0, 2
+x = a or (b and c)  # OK
+x2 = (a or b) and c  # OK
+x3 = (a or b) or c  # OK
+x4 = (a and b) and c  # OK
+
+a, b, c = 0, 1, 2
+y = (a and b) or c  # OK
+yy = a and (b or c)  # OK
+
+a, b, c, d = 1, 2, 0, 3
+if a or b or (c and d):  # OK
+    pass
+
+a, b, c, d = 0, 0, 2, 3
+
+if bool():
+    pass
+elif a or (b and c) or d:  # OK
+    pass
+
+a, b, c, d = 0, 1, 0, 2
+while (a and b) or (c and d):  # OK
+    pass
+
+b, c, d, e = 2, 3, 0, 4
+z = [a for a in range(5) if a or b or c or (d and e)]  # OK
+
+a, b = 1, 2
+if (not a) or b:  # OK
+    if (not a) and b:  # OK
+        pass
+
+a, b, c, d = 0, 1, 3, 0
+assert ((not a) and b) or c or d  # OK

crates/ruff_linter/src/checkers/ast/analyze/deferred_for_loops.rs

@@ -2,7 +2,7 @@ use ruff_python_ast::Stmt;
 
 use crate::checkers::ast::Checker;
 use crate::codes::Rule;
-use crate::rules::{flake8_bugbear, perflint, pyupgrade, refurb};
+use crate::rules::{flake8_bugbear, flake8_simplify, perflint, pyupgrade, refurb};
 
 /// Run lint rules over all deferred for-loops in the [`SemanticModel`].
 pub(crate) fn deferred_for_loops(checker: &mut Checker) {
@@ -27,6 +27,9 @@ pub(crate) fn deferred_for_loops(checker: &mut Checker) {
             if checker.enabled(Rule::UnnecessaryEnumerate) {
                 refurb::rules::unnecessary_enumerate(checker, stmt_for);
             }
+            if checker.enabled(Rule::EnumerateForLoop) {
+                flake8_simplify::rules::enumerate_for_loop(checker, stmt_for);
+            }
         }
     }
 }

crates/ruff_linter/src/checkers/ast/analyze/deferred_scopes.rs

@@ -1,12 +1,14 @@
-use ruff_diagnostics::Diagnostic;
+use ruff_diagnostics::{Diagnostic, Fix};
 use ruff_python_semantic::analyze::visibility;
-use ruff_python_semantic::{Binding, BindingKind, ScopeKind};
+use ruff_python_semantic::{Binding, BindingKind, Imported, ScopeKind};
 use ruff_text_size::Ranged;
 
 use crate::checkers::ast::Checker;
 use crate::codes::Rule;
+use crate::fix;
 use crate::rules::{
-    flake8_pyi, flake8_type_checking, flake8_unused_arguments, pyflakes, pylint, ruff,
+    flake8_builtins, flake8_pyi, flake8_type_checking, flake8_unused_arguments, pyflakes, pylint,
+    ruff,
 };
 
 /// Run lint rules over all deferred scopes in the [`SemanticModel`].
@@ -26,6 +28,7 @@ pub(crate) fn deferred_scopes(checker: &mut Checker) {
         Rule::UndefinedLocal,
         Rule::UnusedAnnotation,
         Rule::UnusedClassMethodArgument,
+        Rule::BuiltinAttributeShadowing,
         Rule::UnusedFunctionArgument,
         Rule::UnusedImport,
         Rule::UnusedLambdaArgument,
@@ -144,9 +147,9 @@ pub(crate) fn deferred_scopes(checker: &mut Checker) {
 
                     // If the bindings are in different forks, abort.
                     if shadowed.source.map_or(true, |left| {
-                        binding.source.map_or(true, |right| {
-                            checker.semantic.different_branches(left, right)
-                        })
+                        binding
+                            .source
+                            .map_or(true, |right| !checker.semantic.same_branch(left, right))
                     }) {
                         continue;
                     }
@@ -233,9 +236,9 @@ pub(crate) fn deferred_scopes(checker: &mut Checker) {
 
                     // If the bindings are in different forks, abort.
                     if shadowed.source.map_or(true, |left| {
-                        binding.source.map_or(true, |right| {
-                            checker.semantic.different_branches(left, right)
-                        })
+                        binding
+                            .source
+                            .map_or(true, |right| !checker.semantic.same_branch(left, right))
                     }) {
                         continue;
                     }
@@ -247,9 +250,33 @@ pub(crate) fn deferred_scopes(checker: &mut Checker) {
                         },
                         binding.range(),
                     );
+
                     if let Some(range) = binding.parent_range(&checker.semantic) {
                         diagnostic.set_parent(range.start());
                     }
+
+                    if checker.settings.preview.is_enabled() {
+                        if let Some(import) = binding.as_any_import() {
+                            if let Some(source) = binding.source {
+                                diagnostic.try_set_fix(|| {
+                                    let statement = checker.semantic().statement(source);
+                                    let parent = checker.semantic().parent_statement(source);
+                                    let edit = fix::edits::remove_unused_imports(
+                                        std::iter::once(import.member_name().as_ref()),
+                                        statement,
+                                        parent,
+                                        checker.locator(),
+                                        checker.stylist(),
+                                        checker.indexer(),
+                                    )?;
+                                    Ok(Fix::safe_edit(edit).isolate(Checker::isolation(
+                                        checker.semantic().parent_statement_id(source),
+                                    )))
+                                });
+                            }
+                        }
+                    }
+
                     diagnostics.push(diagnostic);
                 }
             }
@@ -272,6 +299,18 @@ pub(crate) fn deferred_scopes(checker: &mut Checker) {
             ruff::rules::asyncio_dangling_binding(scope, &checker.semantic, &mut diagnostics);
         }
 
+        if let Some(class_def) = scope.kind.as_class() {
+            if checker.enabled(Rule::BuiltinAttributeShadowing) {
+                flake8_builtins::rules::builtin_attribute_shadowing(
+                    checker,
+                    scope_id,
+                    scope,
+                    class_def,
+                    &mut diagnostics,
+                );
+            }
+        }
+
         if matches!(scope.kind, ScopeKind::Function(_) | ScopeKind::Lambda(_)) {
             if checker.enabled(Rule::UnusedVariable) {
                 pyflakes::rules::unused_variable(checker, scope, &mut diagnostics);

crates/ruff_linter/src/checkers/ast/analyze/expression.rs

@@ -242,13 +242,7 @@ pub(crate) fn expression(expr: &Expr, checker: &mut Checker) {
                             checker.diagnostics.push(diagnostic);
                         }
                     }
-                    if let ScopeKind::Class(class_def) = checker.semantic.current_scope().kind {
-                        if checker.enabled(Rule::BuiltinAttributeShadowing) {
-                            flake8_builtins::rules::builtin_attribute_shadowing(
-                                checker, class_def, id, *range,
-                            );
-                        }
-                    } else {
+                    if !checker.semantic.current_scope().kind.is_class() {
                         if checker.enabled(Rule::BuiltinVariableShadowing) {
                             flake8_builtins::rules::builtin_variable_shadowing(checker, id, *range);
                         }
@@ -724,7 +718,7 @@ pub(crate) fn expression(expr: &Expr, checker: &mut Checker) {
                 );
             }
             if checker.enabled(Rule::BooleanPositionalValueInCall) {
-                flake8_boolean_trap::rules::boolean_positional_value_in_call(checker, args, func);
+                flake8_boolean_trap::rules::boolean_positional_value_in_call(checker, call);
             }
             if checker.enabled(Rule::Debugger) {
                 flake8_debugger::rules::debugger_call(checker, expr, func);
@@ -869,6 +863,9 @@ pub(crate) fn expression(expr: &Expr, checker: &mut Checker) {
             if checker.enabled(Rule::DictGetWithNoneDefault) {
                 flake8_simplify::rules::dict_get_with_none_default(checker, expr);
             }
+            if checker.enabled(Rule::ZipDictKeysAndValues) {
+                flake8_simplify::rules::zip_dict_keys_and_values(checker, call);
+            }
             if checker.any_enabled(&[
                 Rule::OsPathAbspath,
                 Rule::OsChmod,
@@ -983,9 +980,9 @@ pub(crate) fn expression(expr: &Expr, checker: &mut Checker) {
                 flake8_pie::rules::unnecessary_spread(checker, dict);
             }
         }
-        Expr::Set(ast::ExprSet { elts, range: _ }) => {
+        Expr::Set(set) => {
             if checker.enabled(Rule::DuplicateValue) {
-                flake8_bugbear::rules::duplicate_value(checker, elts);
+                flake8_bugbear::rules::duplicate_value(checker, set);
             }
         }
         Expr::Yield(_) => {
@@ -1492,6 +1489,9 @@ pub(crate) fn expression(expr: &Expr, checker: &mut Checker) {
             if checker.enabled(Rule::UnnecessaryKeyCheck) {
                 ruff::rules::unnecessary_key_check(checker, expr);
             }
+            if checker.enabled(Rule::ParenthesizeChainedOperators) {
+                ruff::rules::parenthesize_chained_logical_operators(checker, bool_op);
+            }
         }
         Expr::NamedExpr(..) => {
             if checker.enabled(Rule::AssignmentInAssert) {

crates/ruff_linter/src/checkers/ast/analyze/statement.rs

@@ -347,17 +347,7 @@ pub(crate) fn statement(stmt: &Stmt, checker: &mut Checker) {
             if checker.enabled(Rule::FStringDocstring) {
                 flake8_bugbear::rules::f_string_docstring(checker, body);
             }
-            if let ScopeKind::Class(class_def) = checker.semantic.current_scope().kind {
-                if checker.enabled(Rule::BuiltinAttributeShadowing) {
-                    flake8_builtins::rules::builtin_method_shadowing(
-                        checker,
-                        class_def,
-                        name,
-                        decorator_list,
-                        name.range(),
-                    );
-                }
-            } else {
+            if !checker.semantic.current_scope().kind.is_class() {
                 if checker.enabled(Rule::BuiltinVariableShadowing) {
                     flake8_builtins::rules::builtin_variable_shadowing(checker, name, name.range());
                 }
@@ -365,12 +355,6 @@ pub(crate) fn statement(stmt: &Stmt, checker: &mut Checker) {
             if checker.enabled(Rule::TrioAsyncFunctionWithTimeout) {
                 flake8_trio::rules::async_function_with_timeout(checker, function_def);
             }
-            #[cfg(feature = "unreachable-code")]
-            if checker.enabled(Rule::UnreachableCode) {
-                checker
-                    .diagnostics
-                    .extend(ruff::rules::unreachable::in_function(name, body));
-            }
             if checker.enabled(Rule::ReimplementedOperator) {
                 refurb::rules::reimplemented_operator(checker, &function_def.into());
             }
@@ -1274,9 +1258,10 @@ pub(crate) fn statement(stmt: &Stmt, checker: &mut Checker) {
             },
         ) => {
             if checker.any_enabled(&[
-                Rule::UnusedLoopControlVariable,
+                Rule::EnumerateForLoop,
                 Rule::IncorrectDictIterator,
                 Rule::UnnecessaryEnumerate,
+                Rule::UnusedLoopControlVariable,
                 Rule::YieldInForLoop,
             ]) {
                 checker.deferred.for_loops.push(checker.semantic.snapshot());

crates/ruff_linter/src/checkers/logical_lines.rs

@@ -14,14 +14,15 @@ use crate::rules::pycodestyle::rules::logical_lines::{
 };
 use crate::settings::LinterSettings;
 
-/// Return the amount of indentation, expanding tabs to the next multiple of 8.
-fn expand_indent(line: &str) -> usize {
+/// Return the amount of indentation, expanding tabs to the next multiple of the settings' tab size.
+fn expand_indent(line: &str, settings: &LinterSettings) -> usize {
     let line = line.trim_end_matches(['\n', '\r']);
 
     let mut indent = 0;
+    let tab_size = settings.tab_size.as_usize();
     for c in line.bytes() {
         match c {
-            b'\t' => indent = (indent / 8) * 8 + 8,
+            b'\t' => indent = (indent / tab_size) * tab_size + tab_size,
             b' ' => indent += 1,
             _ => break,
         }
@@ -84,7 +85,7 @@ pub(crate) fn check_logical_lines(
             TextRange::new(locator.line_start(first_token.start()), first_token.start())
         };
 
-        let indent_level = expand_indent(locator.slice(range));
+        let indent_level = expand_indent(locator.slice(range), settings);
 
         let indent_size = 4;
 

crates/ruff_linter/src/codes.rs

@@ -454,6 +454,7 @@ pub fn code_to_rule(linter: Linter, code: &str) -> Option<(RuleGroup, Rule)> {
         (Flake8Simplify, "109") => (RuleGroup::Stable, rules::flake8_simplify::rules::CompareWithTuple),
         (Flake8Simplify, "110") => (RuleGroup::Stable, rules::flake8_simplify::rules::ReimplementedBuiltin),
         (Flake8Simplify, "112") => (RuleGroup::Stable, rules::flake8_simplify::rules::UncapitalizedEnvironmentVariables),
+        (Flake8Simplify, "113") => (RuleGroup::Preview, rules::flake8_simplify::rules::EnumerateForLoop),
         (Flake8Simplify, "114") => (RuleGroup::Stable, rules::flake8_simplify::rules::IfWithSameArms),
         (Flake8Simplify, "115") => (RuleGroup::Stable, rules::flake8_simplify::rules::OpenFileWithContextHandler),
         (Flake8Simplify, "116") => (RuleGroup::Stable, rules::flake8_simplify::rules::IfElseBlockInsteadOfDictLookup),
@@ -472,6 +473,7 @@ pub fn code_to_rule(linter: Linter, code: &str) -> Option<(RuleGroup, Rule)> {
         (Flake8Simplify, "300") => (RuleGroup::Stable, rules::flake8_simplify::rules::YodaConditions),
         (Flake8Simplify, "401") => (RuleGroup::Stable, rules::flake8_simplify::rules::IfElseBlockInsteadOfDictGet),
         (Flake8Simplify, "910") => (RuleGroup::Stable, rules::flake8_simplify::rules::DictGetWithNoneDefault),
+        (Flake8Simplify, "911") => (RuleGroup::Preview, rules::flake8_simplify::rules::ZipDictKeysAndValues),
 
         // flake8-copyright
         #[allow(deprecated)]
@@ -913,9 +915,6 @@ pub fn code_to_rule(linter: Linter, code: &str) -> Option<(RuleGroup, Rule)> {
         (Ruff, "011") => (RuleGroup::Stable, rules::ruff::rules::StaticKeyDictComprehension),
         (Ruff, "012") => (RuleGroup::Stable, rules::ruff::rules::MutableClassDefault),
         (Ruff, "013") => (RuleGroup::Stable, rules::ruff::rules::ImplicitOptional),
-        #[cfg(feature = "unreachable-code")] // When removing this feature gate, also update rules_selector.rs
-        #[allow(deprecated)]
-        (Ruff, "014") => (RuleGroup::Nursery, rules::ruff::rules::UnreachableCode),
         (Ruff, "015") => (RuleGroup::Stable, rules::ruff::rules::UnnecessaryIterableAllocationForFirstElement),
         (Ruff, "016") => (RuleGroup::Stable, rules::ruff::rules::InvalidIndexType),
         #[allow(deprecated)]
@@ -923,6 +922,7 @@ pub fn code_to_rule(linter: Linter, code: &str) -> Option<(RuleGroup, Rule)> {
         (Ruff, "018") => (RuleGroup::Preview, rules::ruff::rules::AssignmentInAssert),
         (Ruff, "019") => (RuleGroup::Preview, rules::ruff::rules::UnnecessaryKeyCheck),
         (Ruff, "020") => (RuleGroup::Preview, rules::ruff::rules::NeverUnion),
+        (Ruff, "021") => (RuleGroup::Preview, rules::ruff::rules::ParenthesizeChainedOperators),
         (Ruff, "100") => (RuleGroup::Stable, rules::ruff::rules::UnusedNOQA),
         (Ruff, "200") => (RuleGroup::Stable, rules::ruff::rules::InvalidPyprojectToml),
 

crates/ruff_linter/src/docstrings/sections.rs

@@ -153,13 +153,17 @@ impl<'a> SectionContexts<'a> {
         while let Some(line) = lines.next() {
             if let Some(section_kind) = suspected_as_section(&line, style) {
                 let indent = leading_space(&line);
-                let section_name = leading_words(&line);
+                let indent_size = indent.text_len();
 
-                let section_name_range = TextRange::at(indent.text_len(), section_name.text_len());
+                let section_name = leading_words(&line);
+                let section_name_size = section_name.text_len();
 
                 if is_docstring_section(
                     &line,
-                    section_name_range,
+                    indent_size,
+                    section_name_size,
+                    section_kind,
+                    last.as_ref(),
                     previous_line.as_ref(),
                     lines.peek(),
                 ) {
@@ -170,7 +174,8 @@ impl<'a> SectionContexts<'a> {
 
                     last = Some(SectionContextData {
                         kind: section_kind,
-                        name_range: section_name_range + line.start(),
+                        indent_size: indent.text_len(),
+                        name_range: TextRange::at(line.start() + indent_size, section_name_size),
                         range: TextRange::empty(line.start()),
                         summary_full_end: line.full_end(),
                     });
@@ -204,8 +209,8 @@ impl<'a> SectionContexts<'a> {
 }
 
 impl<'a> IntoIterator for &'a SectionContexts<'a> {
-    type IntoIter = SectionContextsIter<'a>;
     type Item = SectionContext<'a>;
+    type IntoIter = SectionContextsIter<'a>;
 
     fn into_iter(self) -> Self::IntoIter {
         self.iter()
@@ -257,6 +262,9 @@ impl ExactSizeIterator for SectionContextsIter<'_> {}
 struct SectionContextData {
     kind: SectionKind,
 
+    /// The size of the indentation of the section name.
+    indent_size: TextSize,
+
     /// Range of the section name, relative to the [`Docstring::body`]
     name_range: TextRange,
 
@@ -401,12 +409,15 @@ fn suspected_as_section(line: &str, style: SectionStyle) -> Option<SectionKind>
 /// Check if the suspected context is really a section header.
 fn is_docstring_section(
     line: &Line,
-    section_name_range: TextRange,
+    indent_size: TextSize,
+    section_name_size: TextSize,
+    section_kind: SectionKind,
+    previous_section: Option<&SectionContextData>,
     previous_line: Option<&Line>,
     next_line: Option<&Line>,
 ) -> bool {
     // Determine whether the current line looks like a section header, e.g., "Args:".
-    let section_name_suffix = line[usize::from(section_name_range.end())..].trim();
+    let section_name_suffix = line[usize::from(indent_size + section_name_size)..].trim();
     let this_looks_like_a_section_name =
         section_name_suffix == ":" || section_name_suffix.is_empty();
     if !this_looks_like_a_section_name {
@@ -439,5 +450,25 @@ fn is_docstring_section(
         return false;
     }
 
+    // Determine if this is a sub-section within another section, like `args` in:
+    // ```python
+    // def func(args: tuple[int]):
+    //     """Toggle the gizmo.
+    //
+    //     Args:
+    //         args: The arguments to the function.
+    //     """
+    // ```
+    // However, if the header is an _exact_ match (like `Returns:`, as opposed to `returns:`), then
+    // continue to treat it as a section header.
+    if let Some(previous_section) = previous_section {
+        if previous_section.indent_size < indent_size {
+            let verbatim = &line[TextRange::at(indent_size, section_name_size)];
+            if section_kind.as_str() != verbatim {
+                return false;
+            }
+        }
+    }
+
     true
 }

crates/ruff_linter/src/line_width.rs

@@ -1,4 +1,5 @@
 use std::error::Error;
+use std::fmt;
 use std::hash::Hasher;
 use std::num::{NonZeroU16, NonZeroU8, ParseIntError};
 use std::str::FromStr;
@@ -39,6 +40,12 @@ impl Default for LineLength {
     }
 }
 
+impl fmt::Display for LineLength {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt::Display::fmt(&self.0, f)
+    }
+}
+
 impl CacheKey for LineLength {
     fn cache_key(&self, state: &mut CacheKeyHasher) {
         state.write_u16(self.0.get());
@@ -248,6 +255,12 @@ impl Default for IndentWidth {
     }
 }
 
+impl fmt::Display for IndentWidth {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt::Display::fmt(&self.0, f)
+    }
+}
+
 impl From<NonZeroU8> for IndentWidth {
     fn from(tab_size: NonZeroU8) -> Self {
         Self(tab_size)

crates/ruff_linter/src/registry/rule_set.rs

@@ -1,6 +1,6 @@
 use crate::registry::Rule;
 use ruff_macros::CacheKey;
-use std::fmt::{Debug, Formatter};
+use std::fmt::{Debug, Display, Formatter};
 use std::iter::FusedIterator;
 
 const RULESET_SIZE: usize = 13;
@@ -269,6 +269,21 @@ impl Debug for RuleSet {
     }
 }
 
+impl Display for RuleSet {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        if self.is_empty() {
+            write!(f, "[]")?;
+        } else {
+            writeln!(f, "[")?;
+            for rule in self {
+                writeln!(f, "\t{rule:?},")?;
+            }
+            write!(f, "]")?;
+        }
+        Ok(())
+    }
+}
+
 impl FromIterator<Rule> for RuleSet {
     fn from_iter<T: IntoIterator<Item = Rule>>(iter: T) -> Self {
         let mut set = RuleSet::empty();

crates/ruff_linter/src/rule_selector.rs

@@ -289,9 +289,6 @@ mod schema {
                                 (!prefix.is_empty()).then(|| prefix.to_string())
                             })),
                     )
-                    // Filter out rule gated behind `#[cfg(feature = "unreachable-code")]`, which is
-                    // off-by-default
-                    .filter(|prefix| prefix != "RUF014")
                     .sorted()
                     .map(Value::String)
                     .collect(),
@@ -407,40 +404,28 @@ pub mod clap_completion {
                             let prefix = l.common_prefix();
                             (!prefix.is_empty()).then(|| PossibleValue::new(prefix).help(l.name()))
                         })
-                        .chain(
-                            RuleCodePrefix::iter()
-                                // Filter out rule gated behind `#[cfg(feature = "unreachable-code")]`, which is
-                                // off-by-default
-                                .filter(|prefix| {
-                                    format!(
-                                        "{}{}",
-                                        prefix.linter().common_prefix(),
-                                        prefix.short_code()
-                                    ) != "RUF014"
-                                })
-                                .filter_map(|prefix| {
-                                    // Ex) `UP`
-                                    if prefix.short_code().is_empty() {
-                                        let code = prefix.linter().common_prefix();
-                                        let name = prefix.linter().name();
-                                        return Some(PossibleValue::new(code).help(name));
-                                    }
+                        .chain(RuleCodePrefix::iter().filter_map(|prefix| {
+                            // Ex) `UP`
+                            if prefix.short_code().is_empty() {
+                                let code = prefix.linter().common_prefix();
+                                let name = prefix.linter().name();
+                                return Some(PossibleValue::new(code).help(name));
+                            }
 
-                                    // Ex) `UP004`
-                                    if is_single_rule_selector(&prefix) {
-                                        let rule = prefix.rules().next()?;
-                                        let code = format!(
-                                            "{}{}",
-                                            prefix.linter().common_prefix(),
-                                            prefix.short_code()
-                                        );
-                                        let name: &'static str = rule.into();
-                                        return Some(PossibleValue::new(code).help(name));
-                                    }
+                            // Ex) `UP004`
+                            if is_single_rule_selector(&prefix) {
+                                let rule = prefix.rules().next()?;
+                                let code = format!(
+                                    "{}{}",
+                                    prefix.linter().common_prefix(),
+                                    prefix.short_code()
+                                );
+                                let name: &'static str = rule.into();
+                                return Some(PossibleValue::new(code).help(name));
+                            }
 
-                                    None
-                                }),
-                        ),
+                            None
+                        })),
                 ),
             ))
         }

crates/ruff_linter/src/rules/flake8_annotations/settings.rs

@@ -1,6 +1,8 @@
 //! Settings for the `flake-annotations` plugin.
 
+use crate::display_settings;
 use ruff_macros::CacheKey;
+use std::fmt::{Display, Formatter};
 
 #[derive(Debug, Default, CacheKey)]
 #[allow(clippy::struct_excessive_bools)]
@@ -11,3 +13,20 @@ pub struct Settings {
     pub allow_star_arg_any: bool,
     pub ignore_fully_untyped: bool,
 }
+
+impl Display for Settings {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        display_settings! {
+            formatter = f,
+            namespace = "linter.flake8_annotations",
+            fields = [
+                self.mypy_init_return,
+                self.suppress_dummy_args,
+                self.suppress_none_returning,
+                self.allow_star_arg_any,
+                self.ignore_fully_untyped
+            ]
+        }
+        Ok(())
+    }
+}

crates/ruff_linter/src/rules/flake8_bandit/settings.rs

@@ -1,6 +1,8 @@
 //! Settings for the `flake8-bandit` plugin.
 
+use crate::display_settings;
 use ruff_macros::CacheKey;
+use std::fmt::{Display, Formatter};
 
 pub fn default_tmp_dirs() -> Vec<String> {
     ["/tmp", "/var/tmp", "/dev/shm"]
@@ -22,3 +24,17 @@ impl Default for Settings {
         }
     }
 }
+
+impl Display for Settings {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        display_settings! {
+            formatter = f,
+            namespace = "linter.flake8_bandit",
+            fields = [
+                self.hardcoded_tmp_directory | array,
+                self.check_typed_exception
+            ]
+        }
+        Ok(())
+    }
+}

crates/ruff_linter/src/rules/flake8_boolean_trap/helpers.rs

@@ -51,13 +51,29 @@ pub(super) fn is_allowed_func_def(name: &str) -> bool {
 /// Returns `true` if an argument is allowed to use a boolean trap. To return
 /// `true`, the function name must be explicitly allowed, and the argument must
 /// be either the first or second argument in the call.
-pub(super) fn allow_boolean_trap(func: &Expr) -> bool {
-    if let Expr::Attribute(ast::ExprAttribute { attr, .. }) = func {
-        return is_allowed_func_call(attr);
+pub(super) fn allow_boolean_trap(call: &ast::ExprCall) -> bool {
+    let func_name = match call.func.as_ref() {
+        Expr::Attribute(ast::ExprAttribute { attr, .. }) => attr.as_str(),
+        Expr::Name(ast::ExprName { id, .. }) => id.as_str(),
+        _ => return false,
+    };
+
+    // If the function name is explicitly allowed, then the boolean trap is
+    // allowed.
+    if is_allowed_func_call(func_name) {
+        return true;
     }
 
-    if let Expr::Name(ast::ExprName { id, .. }) = func {
-        return is_allowed_func_call(id);
+    // If the function appears to be a setter (e.g., `set_visible` or `setVisible`), then the
+    // boolean trap is allowed. We want to avoid raising a violation for cases in which the argument
+    // is positional-only and third-party, and this tends to be the case for setters.
+    if call.arguments.args.len() == 1 {
+        if func_name
+            .strip_prefix("set")
+            .is_some_and(|suffix| suffix.starts_with(|c: char| c == '_' || c.is_ascii_uppercase()))
+        {
+            return true;
+        }
     }
 
     false

crates/ruff_linter/src/rules/flake8_boolean_trap/rules/boolean_positional_value_in_call.rs

@@ -1,6 +1,6 @@
 use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};
-use ruff_python_ast::Expr;
+use ruff_python_ast as ast;
 use ruff_text_size::Ranged;
 
 use crate::checkers::ast::Checker;
@@ -45,11 +45,16 @@ impl Violation for BooleanPositionalValueInCall {
     }
 }
 
-pub(crate) fn boolean_positional_value_in_call(checker: &mut Checker, args: &[Expr], func: &Expr) {
-    if allow_boolean_trap(func) {
+pub(crate) fn boolean_positional_value_in_call(checker: &mut Checker, call: &ast::ExprCall) {
+    if allow_boolean_trap(call) {
         return;
     }
-    for arg in args.iter().filter(|arg| arg.is_boolean_literal_expr()) {
+    for arg in call
+        .arguments
+        .args
+        .iter()
+        .filter(|arg| arg.is_boolean_literal_expr())
+    {
         checker
             .diagnostics
             .push(Diagnostic::new(BooleanPositionalValueInCall, arg.range()));

crates/ruff_linter/src/rules/flake8_boolean_trap/snapshots/ruff_linter__rules__flake8_boolean_trap__tests__FBT001_FBT.py.snap

@@ -81,12 +81,12 @@ FBT.py:19:5: FBT001 Boolean-typed positional argument in function definition
 21 |     kwonly_nonvalued_nohint,
    |
 
-FBT.py:89:19: FBT001 Boolean-typed positional argument in function definition
+FBT.py:91:19: FBT001 Boolean-typed positional argument in function definition
    |
-88 |     # FBT001: Boolean positional arg in function definition
-89 |     def foo(self, value: bool) -> None:
+90 |     # FBT001: Boolean positional arg in function definition
+91 |     def foo(self, value: bool) -> None:
    |                   ^^^^^ FBT001
-90 |         pass
+92 |         pass
    |
 
 

crates/ruff_linter/src/rules/flake8_boolean_trap/snapshots/ruff_linter__rules__flake8_boolean_trap__tests__FBT003_FBT.py.snap

@@ -28,14 +28,10 @@ FBT.py:57:17: FBT003 Boolean positional value in function call
 59 | mylist.index(True)
    |
 
-FBT.py:69:38: FBT003 Boolean positional value in function call
-   |
-67 | os.set_blocking(0, False)
-68 | g_action.set_enabled(True)
-69 | settings.set_enable_developer_extras(True)
-   |                                      ^^^^ FBT003
-70 | foo.is_(True)
-71 | bar.is_not(False)
-   |
+FBT.py:121:10: FBT003 Boolean positional value in function call
+    |
+121 | settings(True)
+    |          ^^^^ FBT003
+    |
 
 

crates/ruff_linter/src/rules/flake8_boolean_trap/snapshots/ruff_linter__rules__flake8_boolean_trap__tests__preview__FBT001_FBT.py.snap

@@ -81,26 +81,26 @@ FBT.py:19:5: FBT001 Boolean-typed positional argument in function definition
 21 |     kwonly_nonvalued_nohint,
    |
 
-FBT.py:89:19: FBT001 Boolean-typed positional argument in function definition
+FBT.py:91:19: FBT001 Boolean-typed positional argument in function definition
    |
-88 |     # FBT001: Boolean positional arg in function definition
-89 |     def foo(self, value: bool) -> None:
+90 |     # FBT001: Boolean positional arg in function definition
+91 |     def foo(self, value: bool) -> None:
    |                   ^^^^^ FBT001
-90 |         pass
+92 |         pass
    |
 
-FBT.py:99:10: FBT001 Boolean-typed positional argument in function definition
+FBT.py:101:10: FBT001 Boolean-typed positional argument in function definition
     |
- 99 | def func(x: Union[list, Optional[int | str | float | bool]]):
+101 | def func(x: Union[list, Optional[int | str | float | bool]]):
     |          ^ FBT001
-100 |     pass
+102 |     pass
     |
 
-FBT.py:103:10: FBT001 Boolean-typed positional argument in function definition
+FBT.py:105:10: FBT001 Boolean-typed positional argument in function definition
     |
-103 | def func(x: bool | str):
+105 | def func(x: bool | str):
     |          ^ FBT001
-104 |     pass
+106 |     pass
     |
 
 

crates/ruff_linter/src/rules/flake8_bugbear/mod.rs

@@ -12,6 +12,7 @@ mod tests {
 
     use crate::assert_messages;
     use crate::registry::Rule;
+    use crate::settings::types::PreviewMode;
     use crate::settings::LinterSettings;
     use crate::test::test_path;
 
@@ -69,6 +70,24 @@ mod tests {
         Ok(())
     }
 
+    #[test_case(Rule::DuplicateValue, Path::new("B033.py"))]
+    fn preview_rules(rule_code: Rule, path: &Path) -> Result<()> {
+        let snapshot = format!(
+            "preview__{}_{}",
+            rule_code.noqa_code(),
+            path.to_string_lossy()
+        );
+        let diagnostics = test_path(
+            Path::new("flake8_bugbear").join(path).as_path(),
+            &LinterSettings {
+                preview: PreviewMode::Enabled,
+                ..LinterSettings::for_rule(rule_code)
+            },
+        )?;
+        assert_messages!(snapshot, diagnostics);
+        Ok(())
+    }
+
     #[test]
     fn zip_without_explicit_strict() -> Result<()> {
         let snapshot = "B905.py";

crates/ruff_linter/src/rules/flake8_bugbear/rules/duplicate_value.rs

@@ -1,9 +1,11 @@
-use ruff_python_ast::Expr;
+use anyhow::{Context, Result};
 use rustc_hash::FxHashSet;
 
-use ruff_diagnostics::{Diagnostic, Violation};
+use ruff_diagnostics::{Diagnostic, Edit, Fix, FixAvailability, Violation};
 use ruff_macros::{derive_message_formats, violation};
+use ruff_python_ast as ast;
 use ruff_python_ast::comparable::ComparableExpr;
+use ruff_python_trivia::{SimpleTokenKind, SimpleTokenizer};
 use ruff_text_size::Ranged;
 
 use crate::checkers::ast::Checker;
@@ -31,28 +33,82 @@ pub struct DuplicateValue {
 }
 
 impl Violation for DuplicateValue {
+    const FIX_AVAILABILITY: FixAvailability = FixAvailability::Sometimes;
+
     #[derive_message_formats]
     fn message(&self) -> String {
         let DuplicateValue { value } = self;
         format!("Sets should not contain duplicate item `{value}`")
     }
+
+    fn fix_title(&self) -> Option<String> {
+        Some(format!("Remove duplicate item"))
+    }
 }
 
 /// B033
-pub(crate) fn duplicate_value(checker: &mut Checker, elts: &Vec<Expr>) {
+pub(crate) fn duplicate_value(checker: &mut Checker, set: &ast::ExprSet) {
     let mut seen_values: FxHashSet<ComparableExpr> = FxHashSet::default();
-    for elt in elts {
+    for (index, elt) in set.elts.iter().enumerate() {
         if elt.is_literal_expr() {
             let comparable_value: ComparableExpr = elt.into();
 
             if !seen_values.insert(comparable_value) {
-                checker.diagnostics.push(Diagnostic::new(
+                let mut diagnostic = Diagnostic::new(
                     DuplicateValue {
                         value: checker.generator().expr(elt),
                     },
                     elt.range(),
-                ));
+                );
+
+                if checker.settings.preview.is_enabled() {
+                    diagnostic.try_set_fix(|| {
+                        remove_member(set, index, checker.locator().contents()).map(Fix::safe_edit)
+                    });
+                }
+
+                checker.diagnostics.push(diagnostic);
             }
         };
     }
 }
+
+/// Remove the member at the given index from the [`ast::ExprSet`].
+fn remove_member(set: &ast::ExprSet, index: usize, source: &str) -> Result<Edit> {
+    if index < set.elts.len() - 1 {
+        // Case 1: the expression is _not_ the last node, so delete from the start of the
+        // expression to the end of the subsequent comma.
+        // Ex) Delete `"a"` in `{"a", "b", "c"}`.
+        let mut tokenizer = SimpleTokenizer::starts_at(set.elts[index].end(), source);
+
+        // Find the trailing comma.
+        tokenizer
+            .find(|token| token.kind == SimpleTokenKind::Comma)
+            .context("Unable to find trailing comma")?;
+
+        // Find the next non-whitespace token.
+        let next = tokenizer
+            .find(|token| {
+                token.kind != SimpleTokenKind::Whitespace && token.kind != SimpleTokenKind::Newline
+            })
+            .context("Unable to find next token")?;
+
+        Ok(Edit::deletion(set.elts[index].start(), next.start()))
+    } else if index > 0 {
+        // Case 2: the expression is the last node, but not the _only_ node, so delete from the
+        // start of the previous comma to the end of the expression.
+        // Ex) Delete `"c"` in `{"a", "b", "c"}`.
+        let mut tokenizer = SimpleTokenizer::starts_at(set.elts[index - 1].end(), source);
+
+        // Find the trailing comma.
+        let comma = tokenizer
+            .find(|token| token.kind == SimpleTokenKind::Comma)
+            .context("Unable to find trailing comma")?;
+
+        Ok(Edit::deletion(comma.start(), set.elts[index].end()))
+    } else {
+        // Case 3: expression is the only node, so delete it.
+        // Ex) Delete `"a"` in `{"a"}`.
+        Ok(Edit::range_deletion(set.elts[index].range()))
+    }
+}

crates/ruff_linter/src/rules/flake8_bugbear/rules/unused_loop_control_variable.rs

@@ -2,7 +2,7 @@ use ruff_diagnostics::{Diagnostic, Edit, Fix, FixAvailability, Violation};
 use ruff_macros::{derive_message_formats, violation};
 use ruff_python_ast as ast;
 use ruff_python_ast::helpers;
-use ruff_python_ast::helpers::NameFinder;
+use ruff_python_ast::helpers::{NameFinder, StoredNameFinder};
 use ruff_python_ast::visitor::Visitor;
 use ruff_text_size::Ranged;
 
@@ -80,7 +80,7 @@ impl Violation for UnusedLoopControlVariable {
 /// B007
 pub(crate) fn unused_loop_control_variable(checker: &mut Checker, stmt_for: &ast::StmtFor) {
     let control_names = {
-        let mut finder = NameFinder::default();
+        let mut finder = StoredNameFinder::default();
         finder.visit_expr(stmt_for.target.as_ref());
         finder.names
     };

crates/ruff_linter/src/rules/flake8_bugbear/settings.rs

@@ -1,8 +1,23 @@
 //! Settings for the `flake8-bugbear` plugin.
 
+use crate::display_settings;
 use ruff_macros::CacheKey;
+use std::fmt::{Display, Formatter};
 
 #[derive(Debug, Default, CacheKey)]
 pub struct Settings {
     pub extend_immutable_calls: Vec<String>,
 }
+
+impl Display for Settings {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        display_settings! {
+            formatter = f,
+            namespace = "linter.flake8_bugbear",
+            fields = [
+                self.extend_immutable_calls | array
+            ]
+        }
+        Ok(())
+    }
+}

crates/ruff_linter/src/rules/flake8_bugbear/snapshots/ruff_linter__rules__flake8_bugbear__tests__B033_B033.py.snap

@@ -7,17 +7,85 @@ B033.py:4:35: B033 Sets should not contain duplicate item `"value1"`
 3 | ###
 4 | incorrect_set = {"value1", 23, 5, "value1"}
   |                                   ^^^^^^^^ B033
-5 | incorrect_set = {1, 1}
+5 | incorrect_set = {1, 1, 2}
+6 | incorrect_set_multiline = {
   |
+  = help: Remove duplicate item
 
 B033.py:5:21: B033 Sets should not contain duplicate item `1`
   |
 3 | ###
 4 | incorrect_set = {"value1", 23, 5, "value1"}
-5 | incorrect_set = {1, 1}
+5 | incorrect_set = {1, 1, 2}
   |                     ^ B033
-6 | 
-7 | ###
+6 | incorrect_set_multiline = {
+7 |     "value1",
   |
+  = help: Remove duplicate item
+
+B033.py:10:5: B033 Sets should not contain duplicate item `"value1"`
+   |
+ 8 |     23,
+ 9 |     5,
+10 |     "value1",
+   |     ^^^^^^^^ B033
+11 |     # B033
+12 | }
+   |
+   = help: Remove duplicate item
+
+B033.py:13:21: B033 Sets should not contain duplicate item `1`
+   |
+11 |     # B033
+12 | }
+13 | incorrect_set = {1, 1}
+   |                     ^ B033
+14 | incorrect_set = {1, 1,}
+15 | incorrect_set = {0, 1, 1,}
+   |
+   = help: Remove duplicate item
+
+B033.py:14:21: B033 Sets should not contain duplicate item `1`
+   |
+12 | }
+13 | incorrect_set = {1, 1}
+14 | incorrect_set = {1, 1,}
+   |                     ^ B033
+15 | incorrect_set = {0, 1, 1,}
+16 | incorrect_set = {0, 1, 1}
+   |
+   = help: Remove duplicate item
+
+B033.py:15:24: B033 Sets should not contain duplicate item `1`
+   |
+13 | incorrect_set = {1, 1}
+14 | incorrect_set = {1, 1,}
+15 | incorrect_set = {0, 1, 1,}
+   |                        ^ B033
+16 | incorrect_set = {0, 1, 1}
+17 | incorrect_set = {
+   |
+   = help: Remove duplicate item
+
+B033.py:16:24: B033 Sets should not contain duplicate item `1`
+   |
+14 | incorrect_set = {1, 1,}
+15 | incorrect_set = {0, 1, 1,}
+16 | incorrect_set = {0, 1, 1}
+   |                        ^ B033
+17 | incorrect_set = {
+18 |     0,
+   |
+   = help: Remove duplicate item
+
+B033.py:20:5: B033 Sets should not contain duplicate item `1`
+   |
+18 |     0,
+19 |     1,
+20 |     1,
+   |     ^ B033
+21 | }
+   |
+   = help: Remove duplicate item
 
 

crates/ruff_linter/src/rules/flake8_bugbear/snapshots/ruff_linter__rules__flake8_bugbear__tests__preview__B033_B033.py.snap

@@ -0,0 +1,169 @@
+---
+source: crates/ruff_linter/src/rules/flake8_bugbear/mod.rs
+---
+B033.py:4:35: B033 [*] Sets should not contain duplicate item `"value1"`
+  |
+2 | # Errors.
+3 | ###
+4 | incorrect_set = {"value1", 23, 5, "value1"}
+  |                                   ^^^^^^^^ B033
+5 | incorrect_set = {1, 1, 2}
+6 | incorrect_set_multiline = {
+  |
+  = help: Remove duplicate item
+
+ℹ Safe fix
+1 1 | ###
+2 2 | # Errors.
+3 3 | ###
+4   |-incorrect_set = {"value1", 23, 5, "value1"}
+  4 |+incorrect_set = {"value1", 23, 5}
+5 5 | incorrect_set = {1, 1, 2}
+6 6 | incorrect_set_multiline = {
+7 7 |     "value1",
+
+B033.py:5:21: B033 [*] Sets should not contain duplicate item `1`
+  |
+3 | ###
+4 | incorrect_set = {"value1", 23, 5, "value1"}
+5 | incorrect_set = {1, 1, 2}
+  |                     ^ B033
+6 | incorrect_set_multiline = {
+7 |     "value1",
+  |
+  = help: Remove duplicate item
+
+ℹ Safe fix
+2 2 | # Errors.
+3 3 | ###
+4 4 | incorrect_set = {"value1", 23, 5, "value1"}
+5   |-incorrect_set = {1, 1, 2}
+  5 |+incorrect_set = {1, 2}
+6 6 | incorrect_set_multiline = {
+7 7 |     "value1",
+8 8 |     23,
+
+B033.py:10:5: B033 [*] Sets should not contain duplicate item `"value1"`
+   |
+ 8 |     23,
+ 9 |     5,
+10 |     "value1",
+   |     ^^^^^^^^ B033
+11 |     # B033
+12 | }
+   |
+   = help: Remove duplicate item
+
+ℹ Safe fix
+7  7  |     "value1",
+8  8  |     23,
+9  9  |     5,
+10    |-    "value1",
+11 10 |     # B033
+12 11 | }
+13 12 | incorrect_set = {1, 1}
+
+B033.py:13:21: B033 [*] Sets should not contain duplicate item `1`
+   |
+11 |     # B033
+12 | }
+13 | incorrect_set = {1, 1}
+   |                     ^ B033
+14 | incorrect_set = {1, 1,}
+15 | incorrect_set = {0, 1, 1,}
+   |
+   = help: Remove duplicate item
+
+ℹ Safe fix
+10 10 |     "value1",
+11 11 |     # B033
+12 12 | }
+13    |-incorrect_set = {1, 1}
+   13 |+incorrect_set = {1}
+14 14 | incorrect_set = {1, 1,}
+15 15 | incorrect_set = {0, 1, 1,}
+16 16 | incorrect_set = {0, 1, 1}
+
+B033.py:14:21: B033 [*] Sets should not contain duplicate item `1`
+   |
+12 | }
+13 | incorrect_set = {1, 1}
+14 | incorrect_set = {1, 1,}
+   |                     ^ B033
+15 | incorrect_set = {0, 1, 1,}
+16 | incorrect_set = {0, 1, 1}
+   |
+   = help: Remove duplicate item
+
+ℹ Safe fix
+11 11 |     # B033
+12 12 | }
+13 13 | incorrect_set = {1, 1}
+14    |-incorrect_set = {1, 1,}
+   14 |+incorrect_set = {1,}
+15 15 | incorrect_set = {0, 1, 1,}
+16 16 | incorrect_set = {0, 1, 1}
+17 17 | incorrect_set = {
+
+B033.py:15:24: B033 [*] Sets should not contain duplicate item `1`
+   |
+13 | incorrect_set = {1, 1}
+14 | incorrect_set = {1, 1,}
+15 | incorrect_set = {0, 1, 1,}
+   |                        ^ B033
+16 | incorrect_set = {0, 1, 1}
+17 | incorrect_set = {
+   |
+   = help: Remove duplicate item
+
+ℹ Safe fix
+12 12 | }
+13 13 | incorrect_set = {1, 1}
+14 14 | incorrect_set = {1, 1,}
+15    |-incorrect_set = {0, 1, 1,}
+   15 |+incorrect_set = {0, 1,}
+16 16 | incorrect_set = {0, 1, 1}
+17 17 | incorrect_set = {
+18 18 |     0,
+
+B033.py:16:24: B033 [*] Sets should not contain duplicate item `1`
+   |
+14 | incorrect_set = {1, 1,}
+15 | incorrect_set = {0, 1, 1,}
+16 | incorrect_set = {0, 1, 1}
+   |                        ^ B033
+17 | incorrect_set = {
+18 |     0,
+   |
+   = help: Remove duplicate item
+
+ℹ Safe fix
+13 13 | incorrect_set = {1, 1}
+14 14 | incorrect_set = {1, 1,}
+15 15 | incorrect_set = {0, 1, 1,}
+16    |-incorrect_set = {0, 1, 1}
+   16 |+incorrect_set = {0, 1}
+17 17 | incorrect_set = {
+18 18 |     0,
+19 19 |     1,
+
+B033.py:20:5: B033 [*] Sets should not contain duplicate item `1`
+   |
+18 |     0,
+19 |     1,
+20 |     1,
+   |     ^ B033
+21 | }
+   |
+   = help: Remove duplicate item
+
+ℹ Safe fix
+17 17 | incorrect_set = {
+18 18 |     0,
+19 19 |     1,
+20    |-    1,
+21 20 | }
+22 21 | 
+23 22 | ###
+
+

crates/ruff_linter/src/rules/flake8_builtins/rules/builtin_attribute_shadowing.rs

@@ -1,11 +1,10 @@
-use ruff_python_ast as ast;
-use ruff_python_ast::{Arguments, Decorator};
-use ruff_text_size::TextRange;
-
 use ruff_diagnostics::Diagnostic;
 use ruff_diagnostics::Violation;
 use ruff_macros::{derive_message_formats, violation};
-use ruff_python_semantic::SemanticModel;
+use ruff_python_ast as ast;
+use ruff_python_semantic::{BindingKind, Scope, ScopeId};
+use ruff_source_file::SourceRow;
+use ruff_text_size::Ranged;
 
 use crate::checkers::ast::Checker;
 use crate::rules::flake8_builtins::helpers::shadows_builtin;
@@ -20,6 +19,23 @@ use crate::rules::flake8_builtins::helpers::shadows_builtin;
 /// non-obvious errors, as readers may mistake the attribute for the
 /// builtin and vice versa.
 ///
+/// Since methods and class attributes typically cannot be referenced directly
+/// from outside the class scope, this rule only applies to those methods
+/// and attributes that both shadow a builtin _and_ are referenced from within
+/// the class scope, as in the following example, where the `list[int]` return
+/// type annotation resolves to the `list` method, rather than the builtin:
+///
+/// ```python
+/// class Class:
+///     @staticmethod
+///     def list() -> None:
+///         pass
+///
+///     @staticmethod
+///     def repeat(value: int, times: int) -> list[int]:
+///         return [value] * times
+/// ```
+///
 /// Builtins can be marked as exceptions to this rule via the
 /// [`flake8-builtins.builtins-ignorelist`] configuration option, or
 /// converted to the appropriate dunder method. Methods decorated with
@@ -28,135 +44,112 @@ use crate::rules::flake8_builtins::helpers::shadows_builtin;
 ///
 /// ## Example
 /// ```python
-/// class Shadow:
-///     def int():
-///         return 0
-/// ```
+/// class Class:
+///     @staticmethod
+///     def list() -> None:
+///         pass
 ///
-/// Use instead:
-/// ```python
-/// class Shadow:
-///     def to_int():
-///         return 0
-/// ```
-///
-/// Or:
-/// ```python
-/// class Shadow:
-///     # Callable as `int(shadow)`
-///     def __int__():
-///         return 0
+///     @staticmethod
+///     def repeat(value: int, times: int) -> list[int]:
+///         return [value] * times
 /// ```
 ///
 /// ## Options
 /// - `flake8-builtins.builtins-ignorelist`
-///
-/// ## References
-/// - [_Is it bad practice to use a built-in function name as an attribute or method identifier?_](https://stackoverflow.com/questions/9109333/is-it-bad-practice-to-use-a-built-in-function-name-as-an-attribute-or-method-ide)
-/// - [_Why is it a bad idea to name a variable `id` in Python?_](https://stackoverflow.com/questions/77552/id-is-a-bad-variable-name-in-python)
 #[violation]
 pub struct BuiltinAttributeShadowing {
+    kind: Kind,
     name: String,
+    row: SourceRow,
 }
 
 impl Violation for BuiltinAttributeShadowing {
     #[derive_message_formats]
     fn message(&self) -> String {
-        let BuiltinAttributeShadowing { name } = self;
-        format!("Class attribute `{name}` is shadowing a Python builtin")
+        let BuiltinAttributeShadowing { kind, name, row } = self;
+        match kind {
+            Kind::Attribute => {
+                format!("Python builtin is shadowed by class attribute `{name}` from {row}")
+            }
+            Kind::Method => {
+                format!("Python builtin is shadowed by method `{name}` from {row}")
+            }
+        }
     }
 }
 
 /// A003
 pub(crate) fn builtin_attribute_shadowing(
-    checker: &mut Checker,
+    checker: &Checker,
+    scope_id: ScopeId,
+    scope: &Scope,
     class_def: &ast::StmtClassDef,
-    name: &str,
-    range: TextRange,
+    diagnostics: &mut Vec<Diagnostic>,
 ) {
-    if shadows_builtin(
-        name,
-        &checker.settings.flake8_builtins.builtins_ignorelist,
-        checker.source_type,
-    ) {
-        // Ignore shadowing within `TypedDict` definitions, since these are only accessible through
-        // subscripting and not through attribute access.
-        if class_def
-            .bases()
-            .iter()
-            .any(|base| checker.semantic().match_typing_expr(base, "TypedDict"))
-        {
-            return;
-        }
+    for (name, binding_id) in scope.all_bindings() {
+        let binding = checker.semantic().binding(binding_id);
 
-        checker.diagnostics.push(Diagnostic::new(
-            BuiltinAttributeShadowing {
-                name: name.to_string(),
-            },
-            range,
-        ));
+        // We only care about methods and attributes.
+        let kind = match binding.kind {
+            BindingKind::Assignment | BindingKind::Annotation => Kind::Attribute,
+            BindingKind::FunctionDefinition(_) => Kind::Method,
+            _ => continue,
+        };
+
+        if shadows_builtin(
+            name,
+            &checker.settings.flake8_builtins.builtins_ignorelist,
+            checker.source_type,
+        ) {
+            // Ignore explicit overrides.
+            if class_def.decorator_list.iter().any(|decorator| {
+                checker
+                    .semantic()
+                    .match_typing_expr(&decorator.expression, "override")
+            }) {
+                return;
+            }
+
+            // Class scopes are special, in that you can only reference a binding defined in a
+            // class scope from within the class scope itself. As such, we can safely ignore
+            // methods that weren't referenced from within the class scope. In other words, we're
+            // only trying to identify shadowing as in:
+            // ```python
+            // class Class:
+            //     @staticmethod
+            //     def list() -> None:
+            //         pass
+            //
+            //     @staticmethod
+            //     def repeat(value: int, times: int) -> list[int]:
+            //         return [value] * times
+            // ```
+            for reference in binding
+                .references
+                .iter()
+                .map(|reference_id| checker.semantic().reference(*reference_id))
+                .filter(|reference| {
+                    checker
+                        .semantic()
+                        .first_non_type_parent_scope_id(reference.scope_id())
+                        == Some(scope_id)
+                })
+            {
+                diagnostics.push(Diagnostic::new(
+                    BuiltinAttributeShadowing {
+                        kind,
+                        name: name.to_string(),
+                        row: checker.compute_source_row(binding.start()),
+                    },
+                    reference.range(),
+                ));
+            }
+        }
     }
 }
 
-/// A003
-pub(crate) fn builtin_method_shadowing(
-    checker: &mut Checker,
-    class_def: &ast::StmtClassDef,
-    name: &str,
-    decorator_list: &[Decorator],
-    range: TextRange,
-) {
-    if shadows_builtin(
-        name,
-        &checker.settings.flake8_builtins.builtins_ignorelist,
-        checker.source_type,
-    ) {
-        // Ignore some standard-library methods. Ideally, we'd ignore all overridden methods, since
-        // those should be flagged on the superclass, but that's more difficult.
-        if is_standard_library_override(name, class_def, checker.semantic()) {
-            return;
-        }
-
-        // Ignore explicit overrides.
-        if decorator_list.iter().any(|decorator| {
-            checker
-                .semantic()
-                .match_typing_expr(&decorator.expression, "override")
-        }) {
-            return;
-        }
-
-        checker.diagnostics.push(Diagnostic::new(
-            BuiltinAttributeShadowing {
-                name: name.to_string(),
-            },
-            range,
-        ));
-    }
-}
-
-/// Return `true` if an attribute appears to be an override of a standard-library method.
-fn is_standard_library_override(
-    name: &str,
-    class_def: &ast::StmtClassDef,
-    semantic: &SemanticModel,
-) -> bool {
-    let Some(Arguments { args: bases, .. }) = class_def.arguments.as_deref() else {
-        return false;
-    };
-    match name {
-        // Ex) `Event.set`
-        "set" => bases.iter().any(|base| {
-            semantic
-                .resolve_call_path(base)
-                .is_some_and(|call_path| matches!(call_path.as_slice(), ["threading", "Event"]))
-        }),
-        // Ex) `Filter.filter`
-        "filter" => bases.iter().any(|base| {
-            semantic
-                .resolve_call_path(base)
-                .is_some_and(|call_path| matches!(call_path.as_slice(), ["logging", "Filter"]))
-        }),
-        _ => false,
-    }
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+enum Kind {
+    Attribute,
+    Method,
 }

crates/ruff_linter/src/rules/flake8_builtins/settings.rs

@@ -1,8 +1,23 @@
 //! Settings for the `flake8-builtins` plugin.
 
+use crate::display_settings;
 use ruff_macros::CacheKey;
+use std::fmt::{Display, Formatter};
 
 #[derive(Debug, Default, CacheKey)]
 pub struct Settings {
     pub builtins_ignorelist: Vec<String>,
 }
+
+impl Display for Settings {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        display_settings! {
+            formatter = f,
+            namespace = "linter.flake8_builtins",
+            fields = [
+                self.builtins_ignorelist | array
+            ]
+        }
+        Ok(())
+    }
+}

crates/ruff_linter/src/rules/flake8_builtins/snapshots/ruff_linter__rules__flake8_builtins__tests__A003_A003.py.snap

@@ -1,68 +1,22 @@
 ---
 source: crates/ruff_linter/src/rules/flake8_builtins/mod.rs
 ---
-A003.py:2:5: A003 Class attribute `ImportError` is shadowing a Python builtin
-  |
-1 | class MyClass:
-2 |     ImportError = 4
-  |     ^^^^^^^^^^^ A003
-3 |     id: int
-4 |     dir = "/"
-  |
-
-A003.py:3:5: A003 Class attribute `id` is shadowing a Python builtin
-  |
-1 | class MyClass:
-2 |     ImportError = 4
-3 |     id: int
-  |     ^^ A003
-4 |     dir = "/"
-  |
-
-A003.py:4:5: A003 Class attribute `dir` is shadowing a Python builtin
-  |
-2 |     ImportError = 4
-3 |     id: int
-4 |     dir = "/"
-  |     ^^^ A003
-5 | 
-6 |     def __init__(self):
-  |
-
-A003.py:11:9: A003 Class attribute `str` is shadowing a Python builtin
+A003.py:17:31: A003 Python builtin is shadowed by method `str` from line 14
    |
- 9 |         self.dir = "."
-10 | 
-11 |     def str(self):
-   |         ^^^ A003
-12 |         pass
+15 |         pass
+16 | 
+17 |     def method_usage(self) -> str:
+   |                               ^^^ A003
+18 |         pass
    |
 
-A003.py:29:9: A003 Class attribute `str` is shadowing a Python builtin
+A003.py:20:34: A003 Python builtin is shadowed by class attribute `id` from line 3
    |
-27 |         ...
-28 | 
-29 |     def str(self) -> None:
-   |         ^^^ A003
-30 |         ...
-   |
-
-A003.py:40:9: A003 Class attribute `str` is shadowing a Python builtin
-   |
-38 |         ...
-39 | 
-40 |     def str(self) -> None:
-   |         ^^^ A003
-41 |         ...
-   |
-
-A003.py:52:9: A003 Class attribute `int` is shadowing a Python builtin
-   |
-50 |         pass
-51 | 
-52 |     def int(self):
-   |         ^^^ A003
-53 |         pass
+18 |         pass
+19 | 
+20 |     def attribute_usage(self) -> id:
+   |                                  ^^ A003
+21 |         pass
    |
 
 

crates/ruff_linter/src/rules/flake8_builtins/snapshots/ruff_linter__rules__flake8_builtins__tests__A003_A003.py_builtins_ignorelist.snap

@@ -1,49 +1,13 @@
 ---
 source: crates/ruff_linter/src/rules/flake8_builtins/mod.rs
 ---
-A003.py:2:5: A003 Class attribute `ImportError` is shadowing a Python builtin
-  |
-1 | class MyClass:
-2 |     ImportError = 4
-  |     ^^^^^^^^^^^ A003
-3 |     id: int
-4 |     dir = "/"
-  |
-
-A003.py:11:9: A003 Class attribute `str` is shadowing a Python builtin
+A003.py:17:31: A003 Python builtin is shadowed by method `str` from line 14
    |
- 9 |         self.dir = "."
-10 | 
-11 |     def str(self):
-   |         ^^^ A003
-12 |         pass
-   |
-
-A003.py:29:9: A003 Class attribute `str` is shadowing a Python builtin
-   |
-27 |         ...
-28 | 
-29 |     def str(self) -> None:
-   |         ^^^ A003
-30 |         ...
-   |
-
-A003.py:40:9: A003 Class attribute `str` is shadowing a Python builtin
-   |
-38 |         ...
-39 | 
-40 |     def str(self) -> None:
-   |         ^^^ A003
-41 |         ...
-   |
-
-A003.py:52:9: A003 Class attribute `int` is shadowing a Python builtin
-   |
-50 |         pass
-51 | 
-52 |     def int(self):
-   |         ^^^ A003
-53 |         pass
+15 |         pass
+16 | 
+17 |     def method_usage(self) -> str:
+   |                               ^^^ A003
+18 |         pass
    |
 
 

crates/ruff_linter/src/rules/flake8_comprehensions/fixes.rs

@@ -367,7 +367,7 @@ pub(crate) fn fix_unnecessary_literal_dict(expr: &Expr, checker: &Checker) -> Re
                 comma,
             } = element
             {
-                if let Some(Element::Simple { value: key, .. }) = tuple.elements.get(0) {
+                if let Some(Element::Simple { value: key, .. }) = tuple.elements.first() {
                     if let Some(Element::Simple { value, .. }) = tuple.elements.get(1) {
                         return Ok(DictElement::Simple {
                             key: key.clone(),

crates/ruff_linter/src/rules/flake8_comprehensions/settings.rs

@@ -1,8 +1,23 @@
 //! Settings for the `flake8-comprehensions` plugin.
 
+use crate::display_settings;
 use ruff_macros::CacheKey;
+use std::fmt::{Display, Formatter};
 
 #[derive(Debug, Default, CacheKey)]
 pub struct Settings {
     pub allow_dict_calls_with_keyword_arguments: bool,
 }
+
+impl Display for Settings {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        display_settings! {
+            formatter = f,
+            namespace = "linter.flake8_comprehensions",
+            fields = [
+                self.allow_dict_calls_with_keyword_arguments
+            ]
+        }
+        Ok(())
+    }
+}

crates/ruff_linter/src/rules/flake8_copyright/settings.rs

@@ -2,7 +2,9 @@
 
 use once_cell::sync::Lazy;
 use regex::Regex;
+use std::fmt::{Display, Formatter};
 
+use crate::display_settings;
 use ruff_macros::CacheKey;
 
 #[derive(Debug, CacheKey)]
@@ -24,3 +26,18 @@ impl Default for Settings {
         }
     }
 }
+
+impl Display for Settings {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        display_settings! {
+            formatter = f,
+            namespace = "linter.flake8_copyright",
+            fields = [
+                self.notice_rgx,
+                self.author | optional,
+                self.min_file_size,
+            ]
+        }
+        Ok(())
+    }
+}

crates/ruff_linter/src/rules/flake8_errmsg/settings.rs

@@ -1,8 +1,23 @@
 //! Settings for the `flake8-errmsg` plugin.
 
+use crate::display_settings;
 use ruff_macros::CacheKey;
+use std::fmt::{Display, Formatter};
 
 #[derive(Debug, Default, CacheKey)]
 pub struct Settings {
     pub max_string_length: usize,
 }
+
+impl Display for Settings {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        display_settings! {
+            formatter = f,
+            namespace = "linter.flake8_errmsg",
+            fields = [
+                self.max_string_length
+            ]
+        }
+        Ok(())
+    }
+}

crates/ruff_linter/src/rules/flake8_gettext/settings.rs

@@ -1,4 +1,6 @@
+use crate::display_settings;
 use ruff_macros::CacheKey;
+use std::fmt::{Display, Formatter};
 
 #[derive(Debug, CacheKey)]
 pub struct Settings {
@@ -20,3 +22,16 @@ impl Default for Settings {
         }
     }
 }
+
+impl Display for Settings {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        display_settings! {
+            formatter = f,
+            namespace = "linter.flake8_gettext",
+            fields = [
+                self.functions_names | array
+            ]
+        }
+        Ok(())
+    }
+}

crates/ruff_linter/src/rules/flake8_implicit_str_concat/settings.rs

@@ -1,6 +1,8 @@
 //! Settings for the `flake8-implicit-str-concat` plugin.
 
+use crate::display_settings;
 use ruff_macros::CacheKey;
+use std::fmt::{Display, Formatter};
 
 #[derive(Debug, CacheKey)]
 pub struct Settings {
@@ -14,3 +16,16 @@ impl Default for Settings {
         }
     }
 }
+
+impl Display for Settings {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        display_settings! {
+            formatter = f,
+            namespace = "linter.flake8_implicit_str_concat",
+            fields = [
+                self.allow_multiline
+            ]
+        }
+        Ok(())
+    }
+}

crates/ruff_linter/src/rules/flake8_import_conventions/settings.rs

@@ -1,7 +1,9 @@
 //! Settings for import conventions.
 
 use rustc_hash::{FxHashMap, FxHashSet};
+use std::fmt::{Display, Formatter};
 
+use crate::display_settings;
 use ruff_macros::CacheKey;
 
 const CONVENTIONAL_ALIASES: &[(&str, &str)] = &[
@@ -44,3 +46,18 @@ impl Default for Settings {
         }
     }
 }
+
+impl Display for Settings {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        display_settings! {
+            formatter = f,
+            namespace = "linter.flake8_import_conventions",
+            fields = [
+                self.aliases | debug,
+                self.banned_aliases | debug,
+                self.banned_from | array,
+            ]
+        }
+        Ok(())
+    }
+}

crates/ruff_linter/src/rules/flake8_pie/rules/multiple_starts_ends_with.rs

@@ -134,7 +134,7 @@ pub(crate) fn multiple_starts_ends_with(checker: &mut Checker, expr: &Expr) {
                             format!("Indices should only contain `{attr_name}` calls")
                         )
                     };
-                    args.get(0)
+                    args.first()
                         .unwrap_or_else(|| panic!("`{attr_name}` should have one argument"))
                 })
                 .collect();

crates/ruff_linter/src/rules/flake8_pyi/rules/string_or_bytes_too_long.rs

@@ -2,6 +2,7 @@ use ruff_diagnostics::{AlwaysFixableViolation, Diagnostic, Edit, Fix};
 use ruff_macros::{derive_message_formats, violation};
 use ruff_python_ast::helpers::is_docstring_stmt;
 use ruff_python_ast::{self as ast, StringLike};
+use ruff_python_semantic::SemanticModel;
 use ruff_text_size::Ranged;
 
 use crate::checkers::ast::Checker;
@@ -44,8 +45,14 @@ impl AlwaysFixableViolation for StringOrBytesTooLong {
 
 /// PYI053
 pub(crate) fn string_or_bytes_too_long(checker: &mut Checker, string: StringLike) {
+    let semantic = checker.semantic();
+
     // Ignore docstrings.
-    if is_docstring_stmt(checker.semantic().current_statement()) {
+    if is_docstring_stmt(semantic.current_statement()) {
+        return;
+    }
+
+    if is_warnings_dot_deprecated(semantic.current_expression_parent(), semantic) {
         return;
     }
 
@@ -67,3 +74,21 @@ pub(crate) fn string_or_bytes_too_long(checker: &mut Checker, string: StringLike
     )));
     checker.diagnostics.push(diagnostic);
 }
+
+fn is_warnings_dot_deprecated(expr: Option<&ast::Expr>, semantic: &SemanticModel) -> bool {
+    // Does `expr` represent a call to `warnings.deprecated` or `typing_extensions.deprecated`?
+    let Some(expr) = expr else {
+        return false;
+    };
+    let Some(call) = expr.as_call_expr() else {
+        return false;
+    };
+    semantic
+        .resolve_call_path(&call.func)
+        .is_some_and(|call_path| {
+            matches!(
+                call_path.as_slice(),
+                ["warnings" | "typing_extensions", "deprecated"]
+            )
+        })
+}

crates/ruff_linter/src/rules/flake8_pyi/snapshots/ruff_linter__rules__flake8_pyi__tests__PYI053_PYI053.pyi.snap

@@ -1,128 +1,148 @@
 ---
 source: crates/ruff_linter/src/rules/flake8_pyi/mod.rs
 ---
-PYI053.pyi:3:14: PYI053 [*] String and bytes literals longer than 50 characters are not permitted
+PYI053.pyi:7:14: PYI053 [*] String and bytes literals longer than 50 characters are not permitted
   |
-1 | def f1(x: str = "50 character stringggggggggggggggggggggggggggggggg") -> None: ...  # OK
-2 | def f2(
-3 |     x: str = "51 character stringgggggggggggggggggggggggggggggggg",  # Error: PYI053
+5 | def f1(x: str = "50 character stringggggggggggggggggggggggggggggggg") -> None: ...  # OK
+6 | def f2(
+7 |     x: str = "51 character stringgggggggggggggggggggggggggggggggg",  # Error: PYI053
   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ PYI053
-4 | ) -> None: ...
-5 | def f3(
+8 | ) -> None: ...
+9 | def f3(
   |
   = help: Replace with `...`
 
 ℹ Safe fix
-1 1 | def f1(x: str = "50 character stringggggggggggggggggggggggggggggggg") -> None: ...  # OK
-2 2 | def f2(
-3   |-    x: str = "51 character stringgggggggggggggggggggggggggggggggg",  # Error: PYI053
-  3 |+    x: str = ...,  # Error: PYI053
-4 4 | ) -> None: ...
-5 5 | def f3(
-6 6 |     x: str = "50 character stringgggggggggggggggggggggggggggggg\U0001f600",  # OK
+4 4 | 
+5 5 | def f1(x: str = "50 character stringggggggggggggggggggggggggggggggg") -> None: ...  # OK
+6 6 | def f2(
+7   |-    x: str = "51 character stringgggggggggggggggggggggggggggggggg",  # Error: PYI053
+  7 |+    x: str = ...,  # Error: PYI053
+8 8 | ) -> None: ...
+9 9 | def f3(
+10 10 |     x: str = "50 character stringgggggggggggggggggggggggggggggg\U0001f600",  # OK
 
-PYI053.pyi:9:14: PYI053 [*] String and bytes literals longer than 50 characters are not permitted
+PYI053.pyi:13:14: PYI053 [*] String and bytes literals longer than 50 characters are not permitted
    |
- 7 | ) -> None: ...
- 8 | def f4(
- 9 |     x: str = "51 character stringggggggggggggggggggggggggggggggg\U0001f600",  # Error: PYI053
+11 | ) -> None: ...
+12 | def f4(
+13 |     x: str = "51 character stringggggggggggggggggggggggggggggggg\U0001f600",  # Error: PYI053
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ PYI053
-10 | ) -> None: ...
-11 | def f5(
+14 | ) -> None: ...
+15 | def f5(
    |
    = help: Replace with `...`
 
 ℹ Safe fix
-6  6  |     x: str = "50 character stringgggggggggggggggggggggggggggggg\U0001f600",  # OK
-7  7  | ) -> None: ...
-8  8  | def f4(
-9     |-    x: str = "51 character stringggggggggggggggggggggggggggggggg\U0001f600",  # Error: PYI053
-   9  |+    x: str = ...,  # Error: PYI053
-10 10 | ) -> None: ...
-11 11 | def f5(
-12 12 |     x: bytes = b"50 character byte stringgggggggggggggggggggggggggg",  # OK
+10 10 |     x: str = "50 character stringgggggggggggggggggggggggggggggg\U0001f600",  # OK
+11 11 | ) -> None: ...
+12 12 | def f4(
+13    |-    x: str = "51 character stringggggggggggggggggggggggggggggggg\U0001f600",  # Error: PYI053
+   13 |+    x: str = ...,  # Error: PYI053
+14 14 | ) -> None: ...
+15 15 | def f5(
+16 16 |     x: bytes = b"50 character byte stringgggggggggggggggggggggggggg",  # OK
 
-PYI053.pyi:21:16: PYI053 [*] String and bytes literals longer than 50 characters are not permitted
+PYI053.pyi:25:16: PYI053 [*] String and bytes literals longer than 50 characters are not permitted
    |
-19 | ) -> None: ...
-20 | def f8(
-21 |     x: bytes = b"51 character byte stringgggggggggggggggggggggggggg\xff",  # Error: PYI053
+23 | ) -> None: ...
+24 | def f8(
+25 |     x: bytes = b"51 character byte stringgggggggggggggggggggggggggg\xff",  # Error: PYI053
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ PYI053
-22 | ) -> None: ...
+26 | ) -> None: ...
    |
    = help: Replace with `...`
 
 ℹ Safe fix
-18 18 |     x: bytes = b"50 character byte stringggggggggggggggggggggggggg\xff",  # OK
-19 19 | ) -> None: ...
-20 20 | def f8(
-21    |-    x: bytes = b"51 character byte stringgggggggggggggggggggggggggg\xff",  # Error: PYI053
-   21 |+    x: bytes = ...,  # Error: PYI053
-22 22 | ) -> None: ...
-23 23 | 
-24 24 | foo: str = "50 character stringggggggggggggggggggggggggggggggg"  # OK
-
-PYI053.pyi:26:12: PYI053 [*] String and bytes literals longer than 50 characters are not permitted
-   |
-24 | foo: str = "50 character stringggggggggggggggggggggggggggggggg"  # OK
-25 | 
-26 | bar: str = "51 character stringgggggggggggggggggggggggggggggggg"  # Error: PYI053
-   |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ PYI053
-27 | 
-28 | baz: bytes = b"50 character byte stringgggggggggggggggggggggggggg"  # OK
-   |
-   = help: Replace with `...`
-
-ℹ Safe fix
-23 23 | 
-24 24 | foo: str = "50 character stringggggggggggggggggggggggggggggggg"  # OK
-25 25 | 
-26    |-bar: str = "51 character stringgggggggggggggggggggggggggggggggg"  # Error: PYI053
-   26 |+bar: str = ...  # Error: PYI053
+22 22 |     x: bytes = b"50 character byte stringggggggggggggggggggggggggg\xff",  # OK
+23 23 | ) -> None: ...
+24 24 | def f8(
+25    |-    x: bytes = b"51 character byte stringgggggggggggggggggggggggggg\xff",  # Error: PYI053
+   25 |+    x: bytes = ...,  # Error: PYI053
+26 26 | ) -> None: ...
 27 27 | 
-28 28 | baz: bytes = b"50 character byte stringgggggggggggggggggggggggggg"  # OK
-29 29 | 
+28 28 | foo: str = "50 character stringggggggggggggggggggggggggggggggg"  # OK
 
-PYI053.pyi:30:14: PYI053 [*] String and bytes literals longer than 50 characters are not permitted
+PYI053.pyi:30:12: PYI053 [*] String and bytes literals longer than 50 characters are not permitted
    |
-28 | baz: bytes = b"50 character byte stringgggggggggggggggggggggggggg"  # OK
+28 | foo: str = "50 character stringggggggggggggggggggggggggggggggg"  # OK
 29 | 
-30 | qux: bytes = b"51 character byte stringggggggggggggggggggggggggggg\xff"  # Error: PYI053
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ PYI053
+30 | bar: str = "51 character stringgggggggggggggggggggggggggggggggg"  # Error: PYI053
+   |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ PYI053
 31 | 
-32 | ffoo: str = f"50 character stringggggggggggggggggggggggggggggggg"  # OK
+32 | baz: bytes = b"50 character byte stringgggggggggggggggggggggggggg"  # OK
    |
    = help: Replace with `...`
 
 ℹ Safe fix
 27 27 | 
-28 28 | baz: bytes = b"50 character byte stringgggggggggggggggggggggggggg"  # OK
+28 28 | foo: str = "50 character stringggggggggggggggggggggggggggggggg"  # OK
 29 29 | 
-30    |-qux: bytes = b"51 character byte stringggggggggggggggggggggggggggg\xff"  # Error: PYI053
-   30 |+qux: bytes = ...  # Error: PYI053
+30    |-bar: str = "51 character stringgggggggggggggggggggggggggggggggg"  # Error: PYI053
+   30 |+bar: str = ...  # Error: PYI053
 31 31 | 
-32 32 | ffoo: str = f"50 character stringggggggggggggggggggggggggggggggg"  # OK
+32 32 | baz: bytes = b"50 character byte stringgggggggggggggggggggggggggg"  # OK
 33 33 | 
 
-PYI053.pyi:34:15: PYI053 [*] String and bytes literals longer than 50 characters are not permitted
+PYI053.pyi:34:14: PYI053 [*] String and bytes literals longer than 50 characters are not permitted
    |
-32 | ffoo: str = f"50 character stringggggggggggggggggggggggggggggggg"  # OK
+32 | baz: bytes = b"50 character byte stringgggggggggggggggggggggggggg"  # OK
 33 | 
-34 | fbar: str = f"51 character stringgggggggggggggggggggggggggggggggg"  # Error: PYI053
-   |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ PYI053
+34 | qux: bytes = b"51 character byte stringggggggggggggggggggggggggggg\xff"  # Error: PYI053
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ PYI053
 35 | 
-36 | class Demo:
+36 | ffoo: str = f"50 character stringggggggggggggggggggggggggggggggg"  # OK
    |
    = help: Replace with `...`
 
 ℹ Safe fix
 31 31 | 
-32 32 | ffoo: str = f"50 character stringggggggggggggggggggggggggggggggg"  # OK
+32 32 | baz: bytes = b"50 character byte stringgggggggggggggggggggggggggg"  # OK
 33 33 | 
-34    |-fbar: str = f"51 character stringgggggggggggggggggggggggggggggggg"  # Error: PYI053
-   34 |+fbar: str = f"..."  # Error: PYI053
+34    |-qux: bytes = b"51 character byte stringggggggggggggggggggggggggggg\xff"  # Error: PYI053
+   34 |+qux: bytes = ...  # Error: PYI053
 35 35 | 
-36 36 | class Demo:
-37 37 |     """Docstrings are excluded from this rule. Some padding."""  # OK
+36 36 | ffoo: str = f"50 character stringggggggggggggggggggggggggggggggg"  # OK
+37 37 | 
+
+PYI053.pyi:38:15: PYI053 [*] String and bytes literals longer than 50 characters are not permitted
+   |
+36 | ffoo: str = f"50 character stringggggggggggggggggggggggggggggggg"  # OK
+37 | 
+38 | fbar: str = f"51 character stringgggggggggggggggggggggggggggggggg"  # Error: PYI053
+   |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ PYI053
+39 | 
+40 | class Demo:
+   |
+   = help: Replace with `...`
+
+ℹ Safe fix
+35 35 | 
+36 36 | ffoo: str = f"50 character stringggggggggggggggggggggggggggggggg"  # OK
+37 37 | 
+38    |-fbar: str = f"51 character stringgggggggggggggggggggggggggggggggg"  # Error: PYI053
+   38 |+fbar: str = f"..."  # Error: PYI053
+39 39 | 
+40 40 | class Demo:
+41 41 |     """Docstrings are excluded from this rule. Some padding."""  # OK
+
+PYI053.pyi:64:5: PYI053 [*] String and bytes literals longer than 50 characters are not permitted
+   |
+63 | @not_warnings_dot_deprecated(
+64 |     "Not warnings.deprecated, so this one *should* lead to PYI053 in a stub!"  # Error: PYI053
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ PYI053
+65 | )
+66 | def not_a_deprecated_function() -> None: ...
+   |
+   = help: Replace with `...`
+
+ℹ Safe fix
+61 61 | ) -> Callable[[Callable[[], None]], Callable[[], None]]: ...
+62 62 | 
+63 63 | @not_warnings_dot_deprecated(
+64    |-    "Not warnings.deprecated, so this one *should* lead to PYI053 in a stub!"  # Error: PYI053
+   64 |+    ...  # Error: PYI053
+65 65 | )
+66 66 | def not_a_deprecated_function() -> None: ...
 
 

crates/ruff_linter/src/rules/flake8_pytest_style/settings.rs

@@ -1,7 +1,9 @@
 //! Settings for the `flake8-pytest-style` plugin.
 use std::error::Error;
 use std::fmt;
+use std::fmt::Formatter;
 
+use crate::display_settings;
 use ruff_macros::CacheKey;
 
 use crate::settings::types::IdentifierPattern;
@@ -47,6 +49,25 @@ impl Default for Settings {
     }
 }
 
+impl fmt::Display for Settings {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        display_settings! {
+            formatter = f,
+            namespace = "linter.flake8_pytest_style",
+            fields = [
+                self.fixture_parentheses,
+                self.parametrize_names_type,
+                self.parametrize_values_type,
+                self.parametrize_values_row_type,
+                self.raises_require_match_for | array,
+                self.raises_extend_require_match_for | array,
+                self.mark_parentheses
+            ]
+        }
+        Ok(())
+    }
+}
+
 /// Error returned by the [`TryFrom`] implementation of [`Settings`].
 #[derive(Debug)]
 pub enum SettingsError {

crates/ruff_linter/src/rules/flake8_quotes/rules/avoidable_escaped_quote.rs

@@ -168,7 +168,7 @@ pub(crate) fn avoidable_escaped_quote(
 
         match tok {
             Tok::String {
-                value,
+                value: string_contents,
                 kind,
                 triple_quoted,
             } => {
@@ -176,8 +176,6 @@ pub(crate) fn avoidable_escaped_quote(
                     continue;
                 }
 
-                let string_contents = locator.slice(&value);
-
                 // Check if we're using the preferred quotation style.
                 if !leading_quote(locator.slice(tok_range)).is_some_and(|text| {
                     contains_quote(text, quotes_settings.inline_quotes.as_char())
@@ -314,7 +312,7 @@ pub(crate) fn unnecessary_escaped_quote(
 
         match tok {
             Tok::String {
-                value,
+                value: string_contents,
                 kind,
                 triple_quoted,
             } => {
@@ -322,8 +320,6 @@ pub(crate) fn unnecessary_escaped_quote(
                     continue;
                 }
 
-                let string_contents = locator.slice(&value);
-
                 let leading = match leading_quote(locator.slice(tok_range)) {
                     Some("\"") => Quote::Double,
                     Some("'") => Quote::Single,

crates/ruff_linter/src/rules/flake8_quotes/settings.rs

@@ -1,7 +1,9 @@
 //! Settings for the `flake8-quotes` plugin.
 
 use serde::{Deserialize, Serialize};
+use std::fmt::{Display, Formatter};
 
+use crate::display_settings;
 use ruff_macros::CacheKey;
 
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Serialize, Deserialize, CacheKey)]
@@ -39,6 +41,22 @@ impl Default for Settings {
     }
 }
 
+impl Display for Settings {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        display_settings! {
+            formatter = f,
+            namespace = "linter.flake8_quotes",
+            fields = [
+                self.inline_quotes,
+                self.multiline_quotes,
+                self.docstring_quotes,
+                self.avoid_escape
+            ]
+        }
+        Ok(())
+    }
+}
+
 impl Quote {
     #[must_use]
     pub const fn opposite(self) -> Self {
@@ -56,3 +74,12 @@ impl Quote {
         }
     }
 }
+
+impl Display for Quote {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::Double => write!(f, "double"),
+            Self::Single => write!(f, "single"),
+        }
+    }
+}

crates/ruff_linter/src/rules/flake8_self/settings.rs

@@ -1,6 +1,8 @@
 //! Settings for the `flake8-self` plugin.
 
+use crate::display_settings;
 use ruff_macros::CacheKey;
+use std::fmt::{Display, Formatter};
 
 // By default, ignore the `namedtuple` methods and attributes, as well as the
 // _sunder_ names in Enum, which are underscore-prefixed to prevent conflicts
@@ -27,3 +29,16 @@ impl Default for Settings {
         }
     }
 }
+
+impl Display for Settings {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        display_settings! {
+            formatter = f,
+            namespace = "linter.flake8_self",
+            fields = [
+                self.ignore_names | array
+            ]
+        }
+        Ok(())
+    }
+}

crates/ruff_linter/src/rules/flake8_simplify/mod.rs

@@ -27,6 +27,7 @@ mod tests {
     #[test_case(Rule::ReimplementedBuiltin, Path::new("SIM110.py"))]
     #[test_case(Rule::ReimplementedBuiltin, Path::new("SIM111.py"))]
     #[test_case(Rule::UncapitalizedEnvironmentVariables, Path::new("SIM112.py"))]
+    #[test_case(Rule::EnumerateForLoop, Path::new("SIM113.py"))]
     #[test_case(Rule::OpenFileWithContextHandler, Path::new("SIM115.py"))]
     #[test_case(Rule::MultipleWithStatements, Path::new("SIM117.py"))]
     #[test_case(Rule::InDictKeys, Path::new("SIM118.py"))]

crates/ruff_linter/src/rules/flake8_simplify/rules/ast_bool_op.rs

@@ -287,7 +287,7 @@ impl AlwaysFixableViolation for ExprAndFalse {
 }
 
 /// Return `true` if two `Expr` instances are equivalent names.
-fn is_same_expr<'a>(a: &'a Expr, b: &'a Expr) -> Option<&'a str> {
+pub(crate) fn is_same_expr<'a>(a: &'a Expr, b: &'a Expr) -> Option<&'a str> {
     if let (Expr::Name(ast::ExprName { id: a, .. }), Expr::Name(ast::ExprName { id: b, .. })) =
         (&a, &b)
     {
@@ -379,7 +379,8 @@ pub(crate) fn duplicate_isinstance_call(checker: &mut Checker, expr: &Expr) {
                 ..
             }) = &values[indices[0]]
             {
-                args.get(0).expect("`isinstance` should have two arguments")
+                args.first()
+                    .expect("`isinstance` should have two arguments")
             } else {
                 unreachable!("Indices should only contain `isinstance` calls")
             };

crates/ruff_linter/src/rules/flake8_simplify/rules/ast_expr.rs

@@ -142,7 +142,7 @@ pub(crate) fn use_capital_environment_variables(checker: &mut Checker, expr: &Ex
     else {
         return;
     };
-    let Some(arg) = args.get(0) else {
+    let Some(arg) = args.first() else {
         return;
     };
     let Expr::StringLiteral(ast::ExprStringLiteral { value: env_var, .. }) = arg else {
@@ -249,7 +249,7 @@ pub(crate) fn dict_get_with_none_default(checker: &mut Checker, expr: &Expr) {
     if attr != "get" {
         return;
     }
-    let Some(key) = args.get(0) else {
+    let Some(key) = args.first() else {
         return;
     };
     if !(key.is_literal_expr() || key.is_name_expr()) {

crates/ruff_linter/src/rules/flake8_simplify/rules/enumerate_for_loop.rs

@@ -0,0 +1,192 @@
+use ruff_diagnostics::{Diagnostic, Violation};
+use ruff_macros::{derive_message_formats, violation};
+use ruff_python_ast::statement_visitor::{walk_stmt, StatementVisitor};
+use ruff_python_ast::{self as ast, Expr, Int, Number, Operator, Stmt};
+use ruff_python_semantic::analyze::typing;
+use ruff_text_size::Ranged;
+
+use crate::checkers::ast::Checker;
+
+/// ## What it does
+/// Checks for `for` loops with explicit loop-index variables that can be replaced
+/// with `enumerate()`.
+///
+/// ## Why is this bad?
+/// When iterating over a sequence, it's often desirable to keep track of the
+/// index of each element alongside the element itself. Prefer the `enumerate`
+/// builtin over manually incrementing a counter variable within the loop, as
+/// `enumerate` is more concise and idiomatic.
+///
+/// ## Example
+/// ```python
+/// fruits = ["apple", "banana", "cherry"]
+/// for fruit in fruits:
+///     print(f"{i + 1}. {fruit}")
+///     i += 1
+/// ```
+///
+/// Use instead:
+/// ```python
+/// fruits = ["apple", "banana", "cherry"]
+/// for i, fruit in enumerate(fruits):
+///     print(f"{i + 1}. {fruit}")
+/// ```
+///
+/// ## References
+/// - [Python documentation: `enumerate`](https://docs.python.org/3/library/functions.html#enumerate)
+#[violation]
+pub struct EnumerateForLoop {
+    index: String,
+}
+
+impl Violation for EnumerateForLoop {
+    #[derive_message_formats]
+    fn message(&self) -> String {
+        let EnumerateForLoop { index } = self;
+        format!("Use `enumerate()` for index variable `{index}` in `for` loop")
+    }
+}
+
+/// SIM113
+pub(crate) fn enumerate_for_loop(checker: &mut Checker, for_stmt: &ast::StmtFor) {
+    // If the loop contains a `continue`, abort.
+    let mut visitor = LoopControlFlowVisitor::default();
+    visitor.visit_body(&for_stmt.body);
+    if visitor.has_continue {
+        return;
+    }
+
+    for stmt in &for_stmt.body {
+        // Find the augmented assignment expression (e.g., `i += 1`).
+        if let Some(index) = match_index_increment(stmt) {
+            // Find the binding corresponding to the initialization (e.g., `i = 1`).
+            let Some(id) = checker.semantic().resolve_name(index) else {
+                continue;
+            };
+
+            // If it's not an assignment (e.g., it's a function argument), ignore it.
+            let binding = checker.semantic().binding(id);
+            if !binding.kind.is_assignment() {
+                continue;
+            }
+
+            // If the variable is global or nonlocal, ignore it.
+            if binding.is_global() || binding.is_nonlocal() {
+                continue;
+            }
+
+            // Ensure that the index variable was initialized to 0.
+            let Some(value) = typing::find_binding_value(&index.id, binding, checker.semantic())
+            else {
+                continue;
+            };
+            if !matches!(
+                value,
+                Expr::NumberLiteral(ast::ExprNumberLiteral {
+                    value: Number::Int(Int::ZERO),
+                    ..
+                })
+            ) {
+                continue;
+            }
+
+            // If the binding is not at the same level as the `for` loop (e.g., it's in an `if`),
+            // ignore it.
+            let Some(for_loop_id) = checker.semantic().current_statement_id() else {
+                continue;
+            };
+            let Some(assignment_id) = binding.source else {
+                continue;
+            };
+            if checker.semantic().parent_statement_id(for_loop_id)
+                != checker.semantic().parent_statement_id(assignment_id)
+            {
+                continue;
+            }
+
+            // Identify the binding created by the augmented assignment.
+            // TODO(charlie): There should be a way to go from `ExprName` to `BindingId` (like
+            // `resolve_name`, but for bindings rather than references).
+            let binding = {
+                let mut bindings = checker
+                    .semantic()
+                    .current_scope()
+                    .get_all(&index.id)
+                    .map(|id| checker.semantic().binding(id))
+                    .filter(|binding| for_stmt.range().contains_range(binding.range()));
+
+                let Some(binding) = bindings.next() else {
+                    continue;
+                };
+
+                // If there are multiple assignments to this variable _within_ the loop, ignore it.
+                if bindings.next().is_some() {
+                    continue;
+                }
+
+                binding
+            };
+
+            // If the variable is used outside the loop, ignore it.
+            if binding.references.iter().any(|id| {
+                let reference = checker.semantic().reference(*id);
+                !for_stmt.range().contains_range(reference.range())
+            }) {
+                continue;
+            }
+
+            let diagnostic = Diagnostic::new(
+                EnumerateForLoop {
+                    index: index.id.to_string(),
+                },
+                stmt.range(),
+            );
+            checker.diagnostics.push(diagnostic);
+        }
+    }
+}
+
+/// If the statement is an index increment statement (e.g., `i += 1`), return
+/// the name of the index variable.
+fn match_index_increment(stmt: &Stmt) -> Option<&ast::ExprName> {
+    let Stmt::AugAssign(ast::StmtAugAssign {
+        target,
+        op: Operator::Add,
+        value,
+        ..
+    }) = stmt
+    else {
+        return None;
+    };
+
+    let name = target.as_name_expr()?;
+
+    if matches!(
+        value.as_ref(),
+        Expr::NumberLiteral(ast::ExprNumberLiteral {
+            value: Number::Int(Int::ONE),
+            ..
+        })
+    ) {
+        return Some(name);
+    }
+
+    None
+}
+
+#[derive(Debug, Default)]
+struct LoopControlFlowVisitor {
+    has_continue: bool,
+}
+
+impl StatementVisitor<'_> for LoopControlFlowVisitor {
+    fn visit_stmt(&mut self, stmt: &Stmt) {
+        match stmt {
+            Stmt::Continue(_) => self.has_continue = true,
+            Stmt::FunctionDef(_) | Stmt::ClassDef(_) => {
+                // Don't recurse.
+            }
+            _ => walk_stmt(self, stmt),
+        }
+    }
+}

crates/ruff_linter/src/rules/flake8_simplify/rules/mod.rs

@@ -4,6 +4,7 @@ pub(crate) use ast_ifexp::*;
 pub(crate) use ast_unary_op::*;
 pub(crate) use ast_with::*;
 pub(crate) use collapsible_if::*;
+pub(crate) use enumerate_for_loop::*;
 pub(crate) use if_else_block_instead_of_dict_get::*;
 pub(crate) use if_else_block_instead_of_dict_lookup::*;
 pub(crate) use if_else_block_instead_of_if_exp::*;
@@ -15,6 +16,7 @@ pub(crate) use reimplemented_builtin::*;
 pub(crate) use return_in_try_except_finally::*;
 pub(crate) use suppressible_exception::*;
 pub(crate) use yoda_conditions::*;
+pub(crate) use zip_dict_keys_and_values::*;
 
 mod ast_bool_op;
 mod ast_expr;
@@ -22,6 +24,7 @@ mod ast_ifexp;
 mod ast_unary_op;
 mod ast_with;
 mod collapsible_if;
+mod enumerate_for_loop;
 mod fix_with;
 mod if_else_block_instead_of_dict_get;
 mod if_else_block_instead_of_dict_lookup;
@@ -34,3 +37,4 @@ mod reimplemented_builtin;
 mod return_in_try_except_finally;
 mod suppressible_exception;
 mod yoda_conditions;
+mod zip_dict_keys_and_values;

crates/ruff_linter/src/rules/flake8_simplify/rules/zip_dict_keys_and_values.rs

@@ -0,0 +1,130 @@
+use ast::{ExprAttribute, ExprName, Identifier};
+use ruff_macros::{derive_message_formats, violation};
+use ruff_python_ast::{self as ast, Arguments, Expr, ExprCall};
+use ruff_text_size::Ranged;
+
+use crate::{checkers::ast::Checker, fix::snippet::SourceCodeSnippet};
+use ruff_diagnostics::{AlwaysFixableViolation, Diagnostic, Edit, Fix};
+use ruff_python_semantic::analyze::typing::is_dict;
+
+/// ## What it does
+/// Checks for use of `zip()` to iterate over keys and values of a dictionary at once.
+///
+/// ## Why is this bad?
+/// The `dict` type provides an `.items()` method which is faster and more readable.
+///
+/// ## Example
+/// ```python
+/// flag_stars = {"USA": 50, "Slovenia": 3, "Panama": 2, "Australia": 6}
+///
+/// for country, stars in zip(flag_stars.keys(), flag_stars.values()):
+///     print(f"{country}'s flag has {stars} stars.")
+/// ```
+///
+/// Use instead:
+/// ```python
+/// flag_stars = {"USA": 50, "Slovenia": 3, "Panama": 2, "Australia": 6}
+///
+/// for country, stars in flag_stars.items():
+///     print(f"{country}'s flag has {stars} stars.")
+/// ```
+///
+/// ## References
+/// - [Python documentation: `dict.items`](https://docs.python.org/3/library/stdtypes.html#dict.items)
+#[violation]
+pub struct ZipDictKeysAndValues {
+    expected: SourceCodeSnippet,
+    actual: SourceCodeSnippet,
+}
+
+impl AlwaysFixableViolation for ZipDictKeysAndValues {
+    #[derive_message_formats]
+    fn message(&self) -> String {
+        let ZipDictKeysAndValues { expected, actual } = self;
+        if let (Some(expected), Some(actual)) = (expected.full_display(), actual.full_display()) {
+            format!("Use `{expected}` instead of `{actual}`")
+        } else {
+            format!("Use `dict.items()` instead of `zip(dict.keys(), dict.values())`")
+        }
+    }
+
+    fn fix_title(&self) -> String {
+        let ZipDictKeysAndValues { expected, actual } = self;
+        if let (Some(expected), Some(actual)) = (expected.full_display(), actual.full_display()) {
+            format!("Replace `{actual}` with `{expected}`")
+        } else {
+            "Replace `zip(dict.keys(), dict.values())` with `dict.items()`".to_string()
+        }
+    }
+}
+
+/// SIM911
+pub(crate) fn zip_dict_keys_and_values(checker: &mut Checker, expr: &ExprCall) {
+    let ExprCall {
+        func,
+        arguments: Arguments { args, keywords, .. },
+        ..
+    } = expr;
+    match &keywords[..] {
+        [] => {}
+        [ast::Keyword {
+            arg: Some(name), ..
+        }] if name.as_str() == "strict" => {}
+        _ => return,
+    };
+    if matches!(func.as_ref(), Expr::Name(ExprName { id, .. }) if id != "zip") {
+        return;
+    }
+    let [arg1, arg2] = &args[..] else {
+        return;
+    };
+    let Some((var1, attr1)) = get_var_attr(arg1) else {
+        return;
+    };
+    let Some((var2, attr2)) = get_var_attr(arg2) else {
+        return;
+    };
+    if var1.id != var2.id || attr1 != "keys" || attr2 != "values" {
+        return;
+    }
+
+    let Some(binding) = checker
+        .semantic()
+        .only_binding(var1)
+        .map(|id| checker.semantic().binding(id))
+    else {
+        return;
+    };
+    if !is_dict(binding, checker.semantic()) {
+        return;
+    }
+
+    let expected = format!("{}.items()", checker.locator().slice(var1));
+    let actual = checker.locator().slice(expr);
+
+    let mut diagnostic = Diagnostic::new(
+        ZipDictKeysAndValues {
+            expected: SourceCodeSnippet::new(expected.clone()),
+            actual: SourceCodeSnippet::from_str(actual),
+        },
+        expr.range(),
+    );
+    diagnostic.set_fix(Fix::safe_edit(Edit::range_replacement(
+        expected,
+        expr.range(),
+    )));
+    checker.diagnostics.push(diagnostic);
+}
+
+fn get_var_attr(expr: &Expr) -> Option<(&ExprName, &Identifier)> {
+    let Expr::Call(ast::ExprCall { func, .. }) = expr else {
+        return None;
+    };
+    let Expr::Attribute(ExprAttribute { value, attr, .. }) = func.as_ref() else {
+        return None;
+    };
+    let Expr::Name(var_name) = value.as_ref() else {
+        return None;
+    };
+    Some((var_name, attr))
+}

crates/ruff_linter/src/rules/flake8_simplify/snapshots/ruff_linter__rules__flake8_simplify__tests__SIM113_SIM113.py.snap

@@ -0,0 +1,47 @@
+---
+source: crates/ruff_linter/src/rules/flake8_simplify/mod.rs
+---
+SIM113.py:6:9: SIM113 Use `enumerate()` for index variable `idx` in `for` loop
+  |
+4 |     for x in range(5):
+5 |         g(x, idx)
+6 |         idx += 1
+  |         ^^^^^^^^ SIM113
+7 |         h(x)
+  |
+
+SIM113.py:17:9: SIM113 Use `enumerate()` for index variable `idx` in `for` loop
+   |
+15 |         if g(x):
+16 |             break
+17 |         idx += 1
+   |         ^^^^^^^^ SIM113
+18 |         sum += h(x, idx)
+   |
+
+SIM113.py:27:9: SIM113 Use `enumerate()` for index variable `idx` in `for` loop
+   |
+25 |         g(x)
+26 |         h(x, y)
+27 |         idx += 1
+   |         ^^^^^^^^ SIM113
+   |
+
+SIM113.py:36:9: SIM113 Use `enumerate()` for index variable `idx` in `for` loop
+   |
+34 |     for x in range(5):
+35 |         sum += h(x, idx)
+36 |         idx += 1
+   |         ^^^^^^^^ SIM113
+   |
+
+SIM113.py:44:9: SIM113 Use `enumerate()` for index variable `idx` in `for` loop
+   |
+42 |     for x in range(5):
+43 |         g(x, idx)
+44 |         idx += 1
+   |         ^^^^^^^^ SIM113
+45 |         h(x)
+   |
+
+

crates/ruff_linter/src/rules/flake8_simplify/snapshots/ruff_linter__rules__flake8_simplify__tests__SIM222_SIM222.py.snap

@@ -1040,5 +1040,25 @@ SIM222.py:161:31: SIM222 [*] Use `(int, int, int)` instead of `(int, int, int) o
 161     |-def secondToTime(s0: int) -> ((int, int, int) or str):
     161 |+def secondToTime(s0: int) -> ((int, int, int)):
 162 162 |     m, s = divmod(s0, 60)
+163 163 | 
+164 164 | 
+
+SIM222.py:168:7: SIM222 [*] Use `"bar"` instead of `... or "bar"`
+    |
+166 | print(f"{a}{b}" or "bar")
+167 | print(f"{a}{''}" or "bar")
+168 | print(f"{''}{''}" or "bar")
+    |       ^^^^^^^^^^^^^^^^^^^^ SIM222
+169 | print(f"{1}{''}" or "bar")
+    |
+    = help: Replace with `"bar"`
+
+ℹ Unsafe fix
+165 165 | # Regression test for: https://github.com/astral-sh/ruff/issues/9479
+166 166 | print(f"{a}{b}" or "bar")
+167 167 | print(f"{a}{''}" or "bar")
+168     |-print(f"{''}{''}" or "bar")
+    168 |+print("bar")
+169 169 | print(f"{1}{''}" or "bar")
 
 

crates/ruff_linter/src/rules/flake8_simplify/snapshots/ruff_linter__rules__flake8_simplify__tests__SIM223_SIM223.py.snap

@@ -1003,5 +1003,25 @@ SIM223.py:148:12: SIM223 [*] Use `[]` instead of `[] and ...`
 148     |-if f(a and [] and False and []):  # SIM223
     148 |+if f(a and []):  # SIM223
 149 149 |     pass
+150 150 | 
+151 151 | # Regression test for: https://github.com/astral-sh/ruff/issues/9479
+
+SIM223.py:154:7: SIM223 [*] Use `f"{''}{''}"` instead of `f"{''}{''}" and ...`
+    |
+152 | print(f"{a}{b}" and "bar")
+153 | print(f"{a}{''}" and "bar")
+154 | print(f"{''}{''}" and "bar")
+    |       ^^^^^^^^^^^^^^^^^^^^^ SIM223
+155 | print(f"{1}{''}" and "bar")
+    |
+    = help: Replace with `f"{''}{''}"`
+
+ℹ Unsafe fix
+151 151 | # Regression test for: https://github.com/astral-sh/ruff/issues/9479
+152 152 | print(f"{a}{b}" and "bar")
+153 153 | print(f"{a}{''}" and "bar")
+154     |-print(f"{''}{''}" and "bar")
+    154 |+print(f"{''}{''}")
+155 155 | print(f"{1}{''}" and "bar")
 
 

crates/ruff_linter/src/rules/flake8_tidy_imports/settings.rs

@@ -1,6 +1,8 @@
 use rustc_hash::FxHashMap;
 use serde::{Deserialize, Serialize};
+use std::fmt::{Display, Formatter};
 
+use crate::display_settings;
 use ruff_macros::CacheKey;
 
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, CacheKey)]
@@ -22,9 +24,33 @@ pub enum Strictness {
     All,
 }
 
+impl Display for Strictness {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::Parents => write!(f, "\"parents\""),
+            Self::All => write!(f, "\"all\""),
+        }
+    }
+}
+
 #[derive(Debug, CacheKey, Default)]
 pub struct Settings {
     pub ban_relative_imports: Strictness,
     pub banned_api: FxHashMap<String, ApiBan>,
     pub banned_module_level_imports: Vec<String>,
 }
+
+impl Display for Settings {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        display_settings! {
+            formatter = f,
+            namespace = "linter.flake8_tidy_imports",
+            fields = [
+                self.ban_relative_imports,
+                self.banned_api | debug,
+                self.banned_module_level_imports | array,
+            ]
+        }
+        Ok(())
+    }
+}

crates/ruff_linter/src/rules/flake8_trio/rules/zero_sleep_call.rs

@@ -1,6 +1,6 @@
 use ruff_diagnostics::{AlwaysFixableViolation, Diagnostic, Edit, Fix};
 use ruff_macros::{derive_message_formats, violation};
-use ruff_python_ast::{self as ast, Expr, ExprCall, Int};
+use ruff_python_ast::{self as ast, Expr, ExprCall, Int, Number};
 use ruff_python_semantic::analyze::typing::find_assigned_value;
 use ruff_text_size::Ranged;
 
@@ -65,8 +65,7 @@ pub(crate) fn zero_sleep_call(checker: &mut Checker, call: &ExprCall) {
 
     match arg {
         Expr::NumberLiteral(ast::ExprNumberLiteral { value, .. }) => {
-            let Some(int) = value.as_int() else { return };
-            if *int != Int::ZERO {
+            if !matches!(value, Number::Int(Int::ZERO)) {
                 return;
             }
         }
@@ -74,11 +73,13 @@ pub(crate) fn zero_sleep_call(checker: &mut Checker, call: &ExprCall) {
             let Some(value) = find_assigned_value(id, checker.semantic()) else {
                 return;
             };
-            let Expr::NumberLiteral(ast::ExprNumberLiteral { value: num, .. }) = value else {
-                return;
-            };
-            let Some(int) = num.as_int() else { return };
-            if *int != Int::ZERO {
+            if !matches!(
+                value,
+                Expr::NumberLiteral(ast::ExprNumberLiteral {
+                    value: Number::Int(Int::ZERO),
+                    ..
+                })
+            ) {
                 return;
             }
         }

crates/ruff_linter/src/rules/flake8_type_checking/settings.rs

@@ -1,6 +1,8 @@
 //! Settings for the `flake8-type-checking` plugin.
 
+use crate::display_settings;
 use ruff_macros::CacheKey;
+use std::fmt::{Display, Formatter};
 
 #[derive(Debug, CacheKey)]
 pub struct Settings {
@@ -22,3 +24,20 @@ impl Default for Settings {
         }
     }
 }
+
+impl Display for Settings {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        display_settings! {
+            formatter = f,
+            namespace = "linter.flake8_type_checking",
+            fields = [
+                self.strict,
+                self.exempt_modules | array,
+                self.runtime_required_base_classes | array,
+                self.runtime_required_decorators | array,
+                self.quote_annotations
+            ]
+        }
+        Ok(())
+    }
+}

crates/ruff_linter/src/rules/flake8_unused_arguments/settings.rs

@@ -1,8 +1,23 @@
 //! Settings for the `flake8-unused-arguments` plugin.
 
+use crate::display_settings;
 use ruff_macros::CacheKey;
+use std::fmt::{Display, Formatter};
 
 #[derive(Debug, Default, CacheKey)]
 pub struct Settings {
     pub ignore_variadic_names: bool,
 }
+
+impl Display for Settings {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        display_settings! {
+            formatter = f,
+            namespace = "linter.flake8_unused_arguments",
+            fields = [
+                self.ignore_variadic_names
+            ]
+        }
+        Ok(())
+    }
+}

crates/ruff_linter/src/rules/isort/categorize.rs

@@ -1,4 +1,5 @@
 use std::collections::BTreeMap;
+use std::fmt;
 use std::hash::BuildHasherDefault;
 use std::path::{Path, PathBuf};
 use std::{fs, iter};
@@ -40,6 +41,18 @@ pub enum ImportType {
     LocalFolder,
 }
 
+impl fmt::Display for ImportType {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::Future => write!(f, "future"),
+            Self::StandardLibrary => write!(f, "standard_library"),
+            Self::ThirdParty => write!(f, "third_party"),
+            Self::FirstParty => write!(f, "first_party"),
+            Self::LocalFolder => write!(f, "local_folder"),
+        }
+    }
+}
+
 #[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Clone, Hash, Serialize, Deserialize, CacheKey)]
 #[serde(untagged)]
 #[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
@@ -48,6 +61,15 @@ pub enum ImportSection {
     UserDefined(String),
 }
 
+impl fmt::Display for ImportSection {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::Known(import_type) => write!(f, "known {{ type = {import_type} }}",),
+            Self::UserDefined(string) => fmt::Debug::fmt(string, f),
+        }
+    }
+}
+
 #[derive(Debug)]
 enum Reason<'a> {
     NonZeroLevel,
@@ -378,3 +400,18 @@ impl KnownModules {
         user_defined
     }
 }
+
+impl fmt::Display for KnownModules {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        if self.known.is_empty() {
+            write!(f, "{{}}")?;
+        } else {
+            writeln!(f, "{{")?;
+            for (pattern, import_section) in &self.known {
+                writeln!(f, "\t{pattern} => {import_section:?},")?;
+            }
+            write!(f, "}}")?;
+        }
+        Ok(())
+    }
+}

crates/ruff_linter/src/rules/isort/settings.rs

@@ -3,10 +3,12 @@
 use std::collections::BTreeSet;
 use std::error::Error;
 use std::fmt;
+use std::fmt::{Display, Formatter};
 
 use serde::{Deserialize, Serialize};
 use strum::IntoEnumIterator;
 
+use crate::display_settings;
 use ruff_macros::CacheKey;
 
 use crate::rules::isort::categorize::KnownModules;
@@ -32,6 +34,15 @@ impl Default for RelativeImportsOrder {
     }
 }
 
+impl Display for RelativeImportsOrder {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::ClosestToFurthest => write!(f, "closest_to_furthest"),
+            Self::FurthestToClosest => write!(f, "furthest_to_closest"),
+        }
+    }
+}
+
 #[derive(Debug, CacheKey)]
 #[allow(clippy::struct_excessive_bools)]
 pub struct Settings {
@@ -94,6 +105,43 @@ impl Default for Settings {
     }
 }
 
+impl Display for Settings {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        display_settings! {
+            formatter = f,
+            namespace = "linter.isort",
+            fields = [
+                self.required_imports | array,
+                self.combine_as_imports,
+                self.force_single_line,
+                self.force_sort_within_sections,
+                self.detect_same_package,
+                self.case_sensitive,
+                self.force_wrap_aliases,
+                self.force_to_top | array,
+                self.known_modules,
+                self.order_by_type,
+                self.relative_imports_order,
+                self.single_line_exclusions | array,
+                self.split_on_trailing_comma,
+                self.classes | array,
+                self.constants | array,
+                self.variables | array,
+                self.no_lines_before | array,
+                self.lines_after_imports,
+                self.lines_between_types,
+                self.forced_separate | array,
+                self.section_order | array,
+                self.no_sections,
+                self.from_first,
+                self.length_sort,
+                self.length_sort_straight
+            ]
+        }
+        Ok(())
+    }
+}
+
 /// Error returned by the [`TryFrom`] implementation of [`Settings`].
 #[derive(Debug)]
 pub enum SettingsError {

crates/ruff_linter/src/rules/mccabe/settings.rs

@@ -1,6 +1,8 @@
 //! Settings for the `mccabe` plugin.
 
+use crate::display_settings;
 use ruff_macros::CacheKey;
+use std::fmt::{Display, Formatter};
 
 #[derive(Debug, CacheKey)]
 pub struct Settings {
@@ -16,3 +18,16 @@ impl Default for Settings {
         }
     }
 }
+
+impl Display for Settings {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        display_settings! {
+            formatter = f,
+            namespace = "linter.mccabe",
+            fields = [
+                self.max_complexity
+            ]
+        }
+        Ok(())
+    }
+}