Fix test

**Summary** This fixes a deviation with black where black would remove
empty lines before raw docstrings for some reason.

.github/workflows/docs.yaml

@@ -47,7 +47,7 @@ jobs:
         run: mkdocs build --strict -f mkdocs.generated.yml
       - name: "Deploy to Cloudflare Pages"
         if: ${{ env.CF_API_TOKEN_EXISTS == 'true' }}
-        uses: cloudflare/wrangler-action@v3.1.1
+        uses: cloudflare/wrangler-action@v3.2.0
         with:
           apiToken: ${{ secrets.CF_API_TOKEN }}
           accountId: ${{ secrets.CF_ACCOUNT_ID }}

.github/workflows/playground.yaml

@@ -40,8 +40,9 @@ jobs:
         working-directory: playground
       - name: "Deploy to Cloudflare Pages"
         if: ${{ env.CF_API_TOKEN_EXISTS == 'true' }}
-        uses: cloudflare/wrangler-action@v3.1.1
+        uses: cloudflare/wrangler-action@v3.2.0
         with:
           apiToken: ${{ secrets.CF_API_TOKEN }}
           accountId: ${{ secrets.CF_ACCOUNT_ID }}
-          command: pages deploy playground/dist --project-name=ruff-playground --branch ${GITHUB_HEAD_REF} --commit-hash ${GITHUB_SHA}
+          # `github.head_ref` is only set during pull requests and for manual runs or tags we use `main` to deploy to production
+          command: pages deploy playground/dist --project-name=ruff-playground --branch ${{ github.head_ref || 'main' }} --commit-hash ${GITHUB_SHA}

.pre-commit-config.yaml

@@ -23,6 +23,7 @@ repos:
       - id: mdformat
         additional_dependencies:
           - mdformat-mkdocs
+          - mdformat-admon
 
   - repo: https://github.com/igorshubovych/markdownlint-cli
     rev: v0.33.0

BREAKING_CHANGES.md

@@ -1,5 +1,25 @@
 # Breaking Changes
 
+## 0.1.0
+
+### Unsafe fixes are not applied by default ([#7769](https://github.com/astral-sh/ruff/pull/7769))
+
+Ruff labels fixes as "safe" and "unsafe". The meaning and intent of your code will be retained when applying safe
+fixes, but the meaning could be changed when applying unsafe fixes. Previously, unsafe fixes were always displayed
+and applied when fixing was enabled. Now, unsafe fixes are hidden by default and not applied. The `--unsafe-fixes`
+flag or `unsafe-fixes` configuration option can be used to enable unsafe fixes.
+
+See the [docs](https://docs.astral.sh/ruff/configuration/#fix-safety) for details.
+
+### Remove formatter-conflicting rules from the default rule set  ([#7900](https://github.com/astral-sh/ruff/pull/7900))
+
+Previously, Ruff enabled all implemented rules in Pycodestyle (`E`) by default. Ruff now only includes the
+Pycodestyle prefixes `E4`, `E7`, and `E9` to exclude rules that conflict with automatic formatters. Consequently,
+the stable rule set no longer includes `line-too-long` (`E501`) and `mixed-spaces-and-tabs` (`E101`). Other
+excluded Pycodestyle rules include whitespace enforcement in `E1` and `E2`; these rules are currently in preview, and are already omitted by default.
+
+This change only affects those using Ruff under its default rule set. Users that include `E` in their `select` will experience no change in behavior.
+
 ## 0.0.288
 
 ### Remove support for emoji identifiers ([#7212](https://github.com/astral-sh/ruff/pull/7212))

Cargo.lock

@@ -74,9 +74,9 @@ dependencies = [
 
 [[package]]
 name = "anstream"
-version = "0.5.0"
+version = "0.6.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b1f58811cfac344940f1a400b6e6231ce35171f614f26439e80f8c1465c5cc0c"
+checksum = "2ab91ebe16eb252986481c5b62f6098f3b698a45e34b5b98200cf20dd2484a44"
 dependencies = [
  "anstyle",
  "anstyle-parse",
@@ -112,9 +112,9 @@ dependencies = [
 
 [[package]]
 name = "anstyle-wincon"
-version = "2.1.0"
+version = "3.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "58f54d10c6dfa51283a066ceab3ec1ab78d13fae00aa49243a45e4571fb79dfd"
+checksum = "f0699d10d2f4d628a98ee7b57b289abbc98ff3bad977cb3152709d4bf2330628"
 dependencies = [
  "anstyle",
  "windows-sys 0.48.0",
@@ -221,7 +221,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4c2f7349907b712260e64b0afe2f84692af14a454be26187d9df565c7f69266a"
 dependencies = [
  "memchr",
- "regex-automata 0.3.8",
+ "regex-automata 0.3.9",
  "serde",
 ]
 
@@ -313,9 +313,9 @@ dependencies = [
 
 [[package]]
 name = "clap"
-version = "4.4.5"
+version = "4.4.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "824956d0dca8334758a5b7f7e50518d66ea319330cbceedcf76905c2f6ab30e3"
+checksum = "d04704f56c2cde07f43e8e2c154b43f216dc5c92fc98ada720177362f953b956"
 dependencies = [
  "clap_builder",
  "clap_derive",
@@ -323,9 +323,9 @@ dependencies = [
 
 [[package]]
 name = "clap_builder"
-version = "4.4.5"
+version = "4.4.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "122ec64120a49b4563ccaedcbea7818d069ed8e9aa6d829b82d8a4128936b2ab"
+checksum = "0e231faeaca65ebd1ea3c737966bf858971cd38c3849107aa3ea7de90a804e45"
 dependencies = [
  "anstream",
  "anstyle",
@@ -383,7 +383,7 @@ dependencies = [
  "heck",
  "proc-macro2",
  "quote",
- "syn 2.0.37",
+ "syn 2.0.38",
 ]
 
 [[package]]
@@ -608,7 +608,7 @@ dependencies = [
  "proc-macro2",
  "quote",
  "strsim",
- "syn 2.0.37",
+ "syn 2.0.38",
 ]
 
 [[package]]
@@ -619,7 +619,7 @@ checksum = "836a9bbc7ad63342d6d6e7b815ccab164bc77a2d95d84bc3117a8c0d5c98e2d5"
 dependencies = [
  "darling_core",
  "quote",
- "syn 2.0.37",
+ "syn 2.0.38",
 ]
 
 [[package]]
@@ -872,6 +872,15 @@ dependencies = [
  "libc",
 ]
 
+[[package]]
+name = "getopts"
+version = "0.2.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "14dbbfd5c71d70241ecf9e6f13737f7b5ce823821063188d7e46c41d371eebd5"
+dependencies = [
+ "unicode-width",
+]
+
 [[package]]
 name = "getrandom"
 version = "0.2.10"
@@ -1120,7 +1129,7 @@ dependencies = [
  "pmutil 0.6.1",
  "proc-macro2",
  "quote",
- "syn 2.0.37",
+ "syn 2.0.38",
 ]
 
 [[package]]
@@ -1259,8 +1268,9 @@ checksum = "b4668fb0ea861c1df094127ac5f1da3409a82116a4ba74fca2e58ef927159bb3"
 
 [[package]]
 name = "libcst"
-version = "0.1.0"
-source = "git+https://github.com/Instagram/LibCST.git?rev=03179b55ebe7e916f1722e18e8f0b87c01616d1f#03179b55ebe7e916f1722e18e8f0b87c01616d1f"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bd5c2ff400caac657bf794181d885491bb97cc37c376f8cb4fa3a0cc2176a053"
 dependencies = [
  "chic",
  "libcst_derive",
@@ -1273,8 +1283,9 @@ dependencies = [
 
 [[package]]
 name = "libcst_derive"
-version = "0.1.0"
-source = "git+https://github.com/Instagram/LibCST.git?rev=03179b55ebe7e916f1722e18e8f0b87c01616d1f#03179b55ebe7e916f1722e18e8f0b87c01616d1f"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6d7f252282b20bfec6fae65d351ab1df7e4552a6270dd7bb779ca9d6135aabe9"
 dependencies = [
  "quote",
  "syn 1.0.109",
@@ -1696,7 +1707,7 @@ checksum = "52a40bc70c2c58040d2d8b167ba9a5ff59fc9dab7ad44771cfde3dcfde7a09c6"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.37",
+ "syn 2.0.38",
 ]
 
 [[package]]
@@ -1781,9 +1792,9 @@ dependencies = [
 
 [[package]]
 name = "proc-macro2"
-version = "1.0.67"
+version = "1.0.69"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3d433d9f1a3e8c1263d9456598b16fec66f4acc9a74dacffd35c7bb09b3a1328"
+checksum = "134c189feb4956b20f6f547d2cf727d4c0fe06722b20a0eec87ed445a97f92da"
 dependencies = [
  "unicode-ident",
 ]
@@ -1914,13 +1925,13 @@ dependencies = [
 
 [[package]]
 name = "regex"
-version = "1.9.5"
+version = "1.9.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "697061221ea1b4a94a624f67d0ae2bfe4e22b8a17b6a192afb11046542cc8c47"
+checksum = "ebee201405406dbf528b8b672104ae6d6d63e6d118cb10e4d51abbc7b58044ff"
 dependencies = [
  "aho-corasick",
  "memchr",
- "regex-automata 0.3.8",
+ "regex-automata 0.3.9",
  "regex-syntax 0.7.5",
 ]
 
@@ -1935,9 +1946,9 @@ dependencies = [
 
 [[package]]
 name = "regex-automata"
-version = "0.3.8"
+version = "0.3.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c2f401f4955220693b56f8ec66ee9c78abffd8d1c4f23dc41a23839eb88f0795"
+checksum = "59b23e92ee4318893fa3fe3e6fb365258efbfe6ac6ab30f090cdcbb7aa37efa9"
 dependencies = [
  "aho-corasick",
  "memchr",
@@ -2132,6 +2143,7 @@ name = "ruff_diagnostics"
 version = "0.0.0"
 dependencies = [
  "anyhow",
+ "is-macro",
  "log",
  "ruff_text_size",
  "serde",
@@ -2235,7 +2247,7 @@ dependencies = [
  "proc-macro2",
  "quote",
  "ruff_python_trivia",
- "syn 2.0.37",
+ "syn 2.0.38",
 ]
 
 [[package]]
@@ -2485,6 +2497,7 @@ dependencies = [
  "glob",
  "globset",
  "ignore",
+ "is-macro",
  "itertools 0.11.0",
  "log",
  "once_cell",
@@ -2665,7 +2678,7 @@ checksum = "4eca7ac642d82aa35b60049a6eccb4be6be75e599bd2e9adb5f875a737654af2"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.37",
+ "syn 2.0.38",
 ]
 
 [[package]]
@@ -2727,7 +2740,7 @@ dependencies = [
  "darling",
  "proc-macro2",
  "quote",
- "syn 2.0.37",
+ "syn 2.0.38",
 ]
 
 [[package]]
@@ -2756,9 +2769,9 @@ checksum = "a7cee0529a6d40f580e7a5e6c495c8fbfe21b7b52795ed4bb5e62cdf92bc6380"
 
 [[package]]
 name = "similar"
-version = "2.2.1"
+version = "2.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "420acb44afdae038210c99e69aae24109f32f15500aa708e81d46c9f29d55fcf"
+checksum = "2aeaf503862c419d66959f5d7ca015337d864e9c49485d771b732e2a20453597"
 
 [[package]]
 name = "siphasher"
@@ -2822,7 +2835,7 @@ dependencies = [
  "proc-macro2",
  "quote",
  "rustversion",
- "syn 2.0.37",
+ "syn 2.0.38",
 ]
 
 [[package]]
@@ -2838,9 +2851,9 @@ dependencies = [
 
 [[package]]
 name = "syn"
-version = "2.0.37"
+version = "2.0.38"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7303ef2c05cd654186cb250d29049a24840ca25d2747c25c0381c8d9e2f582e8"
+checksum = "e96b79aaa137db8f61e26363a0c9b47d8b4ec75da28b7d1d614c2303e232408b"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -2927,7 +2940,7 @@ dependencies = [
  "proc-macro-error",
  "proc-macro2",
  "quote",
- "syn 2.0.37",
+ "syn 2.0.38",
 ]
 
 [[package]]
@@ -2939,7 +2952,7 @@ dependencies = [
  "proc-macro-error",
  "proc-macro2",
  "quote",
- "syn 2.0.37",
+ "syn 2.0.38",
  "test-case-core",
 ]
 
@@ -2960,7 +2973,7 @@ checksum = "10712f02019e9288794769fba95cd6847df9874d49d871d062172f9dd41bc4cc"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.37",
+ "syn 2.0.38",
 ]
 
 [[package]]
@@ -2993,6 +3006,22 @@ dependencies = [
  "tikv-jemalloc-sys",
 ]
 
+[[package]]
+name = "time"
+version = "0.3.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cd0cbfecb4d19b5ea75bb31ad904eb5b9fa13f21079c3b92017ebdf4999a5890"
+dependencies = [
+ "serde",
+ "time-core",
+]
+
+[[package]]
+name = "time-core"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2e153e1f1acaef8acc537e68b44906d2db6436e2b35ac2c6b42640fff91f00fd"
+
 [[package]]
 name = "tiny-keccak"
 version = "2.0.2"
@@ -3082,7 +3111,7 @@ checksum = "5f4f31f56159e98206da9efd823404b79b6ef3143b4a7ab76e67b1751b25a4ab"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.37",
+ "syn 2.0.38",
 ]
 
 [[package]]
@@ -3219,10 +3248,23 @@ checksum = "f962df74c8c05a667b5ee8bcf162993134c104e96440b663c8daa176dc772d8c"
 
 [[package]]
 name = "unicode_names2"
-version = "0.6.0"
-source = "git+https://github.com/youknowone/unicode_names2.git?rev=4ce16aa85cbcdd9cc830410f1a72ef9a235f2fde#4ce16aa85cbcdd9cc830410f1a72ef9a235f2fde"
+version = "1.1.0"
+source = "git+https://github.com/konstin/unicode_names2?rev=e2ee8155795a13afbea5caa4dbce8d1f93bc26eb#e2ee8155795a13afbea5caa4dbce8d1f93bc26eb"
 dependencies = [
  "phf",
+ "unicode_names2_generator",
+]
+
+[[package]]
+name = "unicode_names2_generator"
+version = "1.1.0"
+source = "git+https://github.com/konstin/unicode_names2?rev=e2ee8155795a13afbea5caa4dbce8d1f93bc26eb#e2ee8155795a13afbea5caa4dbce8d1f93bc26eb"
+dependencies = [
+ "getopts",
+ "log",
+ "phf_codegen",
+ "rand",
+ "time",
 ]
 
 [[package]]
@@ -3285,7 +3327,7 @@ checksum = "f7e1ba1f333bd65ce3c9f27de592fcbc256dafe3af2717f56d7c87761fbaccf4"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.37",
+ "syn 2.0.38",
 ]
 
 [[package]]
@@ -3379,7 +3421,7 @@ dependencies = [
  "once_cell",
  "proc-macro2",
  "quote",
- "syn 2.0.37",
+ "syn 2.0.38",
  "wasm-bindgen-shared",
 ]
 
@@ -3413,7 +3455,7 @@ checksum = "54681b18a46765f095758388f2d0cf16eb8d4169b639ab575a8f5693af210c7b"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.37",
+ "syn 2.0.38",
  "wasm-bindgen-backend",
  "wasm-bindgen-shared",
 ]

Cargo.toml

@@ -15,7 +15,7 @@ license = "MIT"
 anyhow = { version = "1.0.69" }
 bitflags = { version = "2.3.1" }
 chrono = { version = "0.4.31", default-features = false, features = ["clock"] }
-clap = { version = "4.4.5", features = ["derive"] }
+clap = { version = "4.4.6", features = ["derive"] }
 colored = { version = "2.0.0" }
 filetime = { version = "0.2.20" }
 glob = { version = "0.3.1" }
@@ -24,37 +24,37 @@ ignore = { version = "0.4.20" }
 insta = { version = "1.33.0", feature = ["filters", "glob"] }
 is-macro = { version = "0.3.0" }
 itertools = { version = "0.11.0" }
+libcst = { version = "1.1.0", default-features = false }
 log = { version = "0.4.17" }
-memchr = "2.6.4"
+memchr = { version = "2.6.4" }
 once_cell = { version = "1.17.1" }
 path-absolutize = { version = "3.1.1" }
-proc-macro2 = { version = "1.0.67" }
+proc-macro2 = { version = "1.0.69" }
 quote = { version = "1.0.23" }
-regex = { version = "1.9.5" }
+regex = { version = "1.9.6" }
 rustc-hash = { version = "1.1.0" }
 schemars = { version = "0.8.15" }
 serde = { version = "1.0.152", features = ["derive"] }
 serde_json = { version = "1.0.107" }
 shellexpand = { version = "3.0.0" }
-similar = { version = "2.2.1", features = ["inline"] }
+similar = { version = "2.3.0", features = ["inline"] }
 smallvec = { version = "1.11.1" }
 static_assertions = "1.1.0"
 strum = { version = "0.25.0", features = ["strum_macros"] }
 strum_macros = { version = "0.25.2" }
-syn = { version = "2.0.37" }
+syn = { version = "2.0.38" }
 test-case = { version = "3.2.1" }
 thiserror = { version = "1.0.49" }
 toml = { version = "0.7.8" }
-tracing = "0.1.37"
-tracing-indicatif = "0.3.4"
+tracing = { version = "0.1.37" }
+tracing-indicatif = { version = "0.3.4" }
 tracing-subscriber = { version = "0.3.17", features = ["env-filter"] }
-unicode-ident = "1.0.12"
-unicode-width = "0.1.11"
+unicode-ident = { version = "1.0.12" }
+unicode_names2 = { git = "https://github.com/konstin/unicode_names2", rev = "e2ee8155795a13afbea5caa4dbce8d1f93bc26eb" }
+unicode-width = { version = "0.1.11" }
 uuid = { version = "1.4.1", features = ["v4", "fast-rng", "macro-diagnostics", "js"] }
 wsl = { version = "0.1.0" }
 
-libcst = { git = "https://github.com/Instagram/LibCST.git", rev = "03179b55ebe7e916f1722e18e8f0b87c01616d1f", default-features = false }
-
 [profile.release]
 lto = "fat"
 codegen-units = 1

README.md

@@ -172,8 +172,8 @@ If left unspecified, the default configuration is equivalent to:
 
 ```toml
 [tool.ruff]
-# Enable pycodestyle (`E`) and Pyflakes (`F`) codes by default.
-select = ["E", "F"]
+# Enable Pyflakes (`F`) and a subset of the pycodestyle (`E`)  codes by default.
+select = ["E4", "E7", "E9", "F"]
 ignore = []
 
 # Allow fix for all enabled rules (when `--fix`) is provided.
@@ -239,7 +239,7 @@ Rust as a first-party feature.
 
 By default, Ruff enables Flake8's `E` and `F` rules. Ruff supports all rules from the `F` category,
 and a [subset](https://docs.astral.sh/ruff/rules/#error-e) of the `E` category, omitting those
-stylistic rules made obsolete by the use of an autoformatter, like
+stylistic rules made obsolete by the use of a formatter, like
 [Black](https://github.com/psf/black).
 
 If you're just getting started with Ruff, **the default rule set is a great place to start**: it

crates/flake8_to_ruff/src/converter.rs

@@ -13,6 +13,7 @@ use ruff_linter::rules::flake8_quotes::settings::Quote;
 use ruff_linter::rules::flake8_tidy_imports::settings::Strictness;
 use ruff_linter::rules::pydocstyle::settings::Convention;
 use ruff_linter::settings::types::PythonVersion;
+use ruff_linter::settings::DEFAULT_SELECTORS;
 use ruff_linter::warn_user;
 use ruff_workspace::options::{
     Flake8AnnotationsOptions, Flake8BugbearOptions, Flake8BuiltinsOptions, Flake8ErrMsgOptions,
@@ -25,11 +26,6 @@ use super::external_config::ExternalConfig;
 use super::plugin::Plugin;
 use super::{parser, plugin};
 
-const DEFAULT_SELECTORS: &[RuleSelector] = &[
-    RuleSelector::Linter(Linter::Pyflakes),
-    RuleSelector::Linter(Linter::Pycodestyle),
-];
-
 pub(crate) fn convert(
     config: &HashMap<String, HashMap<String, Option<String>>>,
     external_config: &ExternalConfig,

crates/ruff_cli/src/args.rs

@@ -9,6 +9,7 @@ use ruff_linter::logging::LogLevel;
 use ruff_linter::registry::Rule;
 use ruff_linter::settings::types::{
     FilePattern, PatternPrefixPair, PerFileIgnore, PreviewMode, PythonVersion, SerializationFormat,
+    UnsafeFixes,
 };
 use ruff_linter::{RuleParser, RuleSelector, RuleSelectorParser};
 use ruff_workspace::configuration::{Configuration, RuleSelection};
@@ -76,12 +77,18 @@ pub enum Command {
 pub struct CheckCommand {
     /// List of files or directories to check.
     pub files: Vec<PathBuf>,
-    /// Attempt to automatically fix lint violations.
-    /// Use `--no-fix` to disable.
+    /// Apply fixes to resolve lint violations.
+    /// Use `--no-fix` to disable or `--unsafe-fixes` to include unsafe fixes.
     #[arg(long, overrides_with("no_fix"))]
     fix: bool,
     #[clap(long, overrides_with("fix"), hide = true)]
     no_fix: bool,
+    /// Include fixes that may not retain the original intent of the code.
+    /// Use `--no-unsafe-fixes` to disable.
+    #[arg(long, overrides_with("no_unsafe_fixes"))]
+    unsafe_fixes: bool,
+    #[arg(long, overrides_with("unsafe_fixes"), hide = true)]
+    no_unsafe_fixes: bool,
     /// Show violations with source code.
     /// Use `--no-show-source` to disable.
     #[arg(long, overrides_with("no_show_source"))]
@@ -100,8 +107,8 @@ pub struct CheckCommand {
     /// Run in watch mode by re-running whenever files change.
     #[arg(short, long)]
     pub watch: bool,
-    /// Fix any fixable lint violations, but don't report on leftover violations. Implies `--fix`.
-    /// Use `--no-fix-only` to disable.
+    /// Apply fixes to resolve lint violations, but don't report on leftover violations. Implies `--fix`.
+    /// Use `--no-fix-only` to disable or `--unsafe-fixes` to include unsafe fixes.
     #[arg(long, overrides_with("no_fix_only"))]
     fix_only: bool,
     #[clap(long, overrides_with("fix_only"), hide = true)]
@@ -497,6 +504,8 @@ impl CheckCommand {
                 cache_dir: self.cache_dir,
                 fix: resolve_bool_arg(self.fix, self.no_fix),
                 fix_only: resolve_bool_arg(self.fix_only, self.no_fix_only),
+                unsafe_fixes: resolve_bool_arg(self.unsafe_fixes, self.no_unsafe_fixes)
+                    .map(UnsafeFixes::from),
                 force_exclude: resolve_bool_arg(self.force_exclude, self.no_force_exclude),
                 output_format: self.output_format.or(self.format),
                 show_fixes: resolve_bool_arg(self.show_fixes, self.no_show_fixes),
@@ -599,6 +608,7 @@ pub struct CliOverrides {
     pub cache_dir: Option<PathBuf>,
     pub fix: Option<bool>,
     pub fix_only: Option<bool>,
+    pub unsafe_fixes: Option<UnsafeFixes>,
     pub force_exclude: Option<bool>,
     pub output_format: Option<SerializationFormat>,
     pub show_fixes: Option<bool>,
@@ -624,6 +634,9 @@ impl ConfigurationTransformer for CliOverrides {
         if let Some(fix_only) = &self.fix_only {
             config.fix_only = Some(*fix_only);
         }
+        if self.unsafe_fixes.is_some() {
+            config.unsafe_fixes = self.unsafe_fixes;
+        }
         config.lint.rule_selections.push(RuleSelection {
             select: self.select.clone(),
             ignore: self

crates/ruff_cli/src/cache.rs

@@ -338,6 +338,7 @@ pub(crate) fn init(path: &Path) -> Result<()> {
 #[cfg(test)]
 mod tests {
     use filetime::{set_file_mtime, FileTime};
+    use ruff_linter::settings::types::UnsafeFixes;
     use std::env::temp_dir;
     use std::fs;
     use std::io;
@@ -410,6 +411,7 @@ mod tests {
                     Some(&cache),
                     flags::Noqa::Enabled,
                     flags::FixMode::Generate,
+                    UnsafeFixes::Enabled,
                 )
                 .unwrap();
                 if diagnostics
@@ -455,6 +457,7 @@ mod tests {
                 Some(&cache),
                 flags::Noqa::Enabled,
                 flags::FixMode::Generate,
+                UnsafeFixes::Enabled,
             )
             .unwrap();
         }
@@ -712,6 +715,7 @@ mod tests {
                 Some(cache),
                 flags::Noqa::Enabled,
                 flags::FixMode::Generate,
+                UnsafeFixes::Enabled,
             )
         }
     }

crates/ruff_cli/src/commands/check.rs

@@ -11,6 +11,7 @@ use itertools::Itertools;
 use log::{debug, error, warn};
 #[cfg(not(target_family = "wasm"))]
 use rayon::prelude::*;
+use ruff_linter::settings::types::UnsafeFixes;
 use rustc_hash::FxHashMap;
 
 use ruff_diagnostics::Diagnostic;
@@ -36,6 +37,7 @@ pub(crate) fn check(
     cache: flags::Cache,
     noqa: flags::Noqa,
     fix_mode: flags::FixMode,
+    unsafe_fixes: UnsafeFixes,
 ) -> Result<Diagnostics> {
     // Collect all the Python files to check.
     let start = Instant::now();
@@ -119,7 +121,16 @@ pub(crate) fn check(
                         }
                     });
 
-                    lint_path(path, package, &settings.linter, cache, noqa, fix_mode).map_err(|e| {
+                    lint_path(
+                        path,
+                        package,
+                        &settings.linter,
+                        cache,
+                        noqa,
+                        fix_mode,
+                        unsafe_fixes,
+                    )
+                    .map_err(|e| {
                         (Some(path.to_owned()), {
                             let mut error = e.to_string();
                             for cause in e.chain() {
@@ -199,9 +210,10 @@ fn lint_path(
     cache: Option<&Cache>,
     noqa: flags::Noqa,
     fix_mode: flags::FixMode,
+    unsafe_fixes: UnsafeFixes,
 ) -> Result<Diagnostics> {
     let result = catch_unwind(|| {
-        crate::diagnostics::lint_path(path, package, settings, cache, noqa, fix_mode)
+        crate::diagnostics::lint_path(path, package, settings, cache, noqa, fix_mode, unsafe_fixes)
     });
 
     match result {
@@ -233,6 +245,8 @@ mod test {
     use std::os::unix::fs::OpenOptionsExt;
 
     use anyhow::Result;
+
+    use ruff_linter::settings::types::UnsafeFixes;
     use rustc_hash::FxHashMap;
     use tempfile::TempDir;
 
@@ -285,6 +299,7 @@ mod test {
             flags::Cache::Disabled,
             flags::Noqa::Disabled,
             flags::FixMode::Generate,
+            UnsafeFixes::Enabled,
         )
         .unwrap();
         let mut output = Vec::new();

crates/ruff_cli/src/commands/format.rs

@@ -66,23 +66,21 @@ pub(crate) fn format(
         .filter_map(|entry| {
             match entry {
                 Ok(entry) => {
-                    let path = entry.path();
+                    let path = entry.into_path();
 
-                    let SourceType::Python(source_type) = SourceType::from(path) else {
+                    let SourceType::Python(source_type) = SourceType::from(&path) else {
                         // Ignore any non-Python files.
                         return None;
                     };
 
-                    let resolved_settings = resolver.resolve(path, &pyproject_config);
+                    let resolved_settings = resolver.resolve(&path, &pyproject_config);
 
                     Some(
                         match catch_unwind(|| {
-                            format_path(path, &resolved_settings.formatter, source_type, mode)
+                            format_path(&path, &resolved_settings.formatter, source_type, mode)
                         }) {
-                            Ok(inner) => inner,
-                            Err(error) => {
-                                Err(FormatCommandError::Panic(Some(path.to_path_buf()), error))
-                            }
+                            Ok(inner) => inner.map(|result| FormatPathResult { path, result }),
+                            Err(error) => Err(FormatCommandError::Panic(Some(path), error)),
                         },
                     )
                 }
@@ -106,7 +104,7 @@ pub(crate) fn format(
         error!("{error}");
     }
 
-    let summary = FormatResultSummary::new(results, mode);
+    let summary = FormatSummary::new(results.as_slice(), mode);
 
     // Report on the formatting changes.
     if log_level >= LogLevel::Default {
@@ -126,7 +124,7 @@ pub(crate) fn format(
         }
         FormatMode::Check => {
             if errors.is_empty() {
-                if summary.formatted > 0 {
+                if summary.any_formatted() {
                     Ok(ExitStatus::Failure)
                 } else {
                     Ok(ExitStatus::Success)
@@ -145,11 +143,11 @@ fn format_path(
     settings: &FormatterSettings,
     source_type: PySourceType,
     mode: FormatMode,
-) -> Result<FormatCommandResult, FormatCommandError> {
+) -> Result<FormatResult, FormatCommandError> {
     // Extract the sources from the file.
     let source_kind = match SourceKind::from_path(path, source_type) {
         Ok(Some(source_kind)) => source_kind,
-        Ok(None) => return Ok(FormatCommandResult::Unchanged),
+        Ok(None) => return Ok(FormatResult::Unchanged),
         Err(err) => {
             return Err(FormatCommandError::Read(Some(path.to_path_buf()), err));
         }
@@ -166,9 +164,9 @@ fn format_path(
                     .write(&mut writer)
                     .map_err(|err| FormatCommandError::Write(Some(path.to_path_buf()), err))?;
             }
-            Ok(FormatCommandResult::Formatted)
+            Ok(FormatResult::Formatted)
         }
-        FormattedSource::Unchanged(_) => Ok(FormatCommandResult::Unchanged),
+        FormattedSource::Unchanged(_) => Ok(FormatResult::Unchanged),
     }
 }
 
@@ -180,11 +178,11 @@ pub(crate) enum FormattedSource {
     Unchanged(SourceKind),
 }
 
-impl From<FormattedSource> for FormatCommandResult {
+impl From<FormattedSource> for FormatResult {
     fn from(value: FormattedSource) -> Self {
         match value {
-            FormattedSource::Formatted(_) => FormatCommandResult::Formatted,
-            FormattedSource::Unchanged(_) => FormatCommandResult::Unchanged,
+            FormattedSource::Formatted(_) => FormatResult::Formatted,
+            FormattedSource::Unchanged(_) => FormatResult::Unchanged,
         }
     }
 }
@@ -292,73 +290,97 @@ pub(crate) fn format_source(
     }
 }
 
+/// The result of an individual formatting operation.
 #[derive(Debug, Clone, Copy, is_macro::Is)]
-pub(crate) enum FormatCommandResult {
+pub(crate) enum FormatResult {
     /// The file was formatted.
     Formatted,
     /// The file was unchanged, as the formatted contents matched the existing contents.
     Unchanged,
 }
 
+/// The coupling of a [`FormatResult`] with the path of the file that was analyzed.
 #[derive(Debug)]
-struct FormatResultSummary {
-    /// The format mode that was used.
-    mode: FormatMode,
-    /// The number of files that were formatted.
-    formatted: usize,
-    /// The number of files that were unchanged.
-    unchanged: usize,
+struct FormatPathResult {
+    path: PathBuf,
+    result: FormatResult,
 }
 
-impl FormatResultSummary {
-    fn new(diagnostics: Vec<FormatCommandResult>, mode: FormatMode) -> Self {
-        let mut summary = Self {
-            mode,
-            formatted: 0,
-            unchanged: 0,
-        };
-        for diagnostic in diagnostics {
-            match diagnostic {
-                FormatCommandResult::Formatted => summary.formatted += 1,
-                FormatCommandResult::Unchanged => summary.unchanged += 1,
-            }
-        }
-        summary
+/// A summary of the formatting results.
+#[derive(Debug)]
+struct FormatSummary<'a> {
+    /// The individual formatting results.
+    results: &'a [FormatPathResult],
+    /// The format mode that was used.
+    mode: FormatMode,
+}
+
+impl<'a> FormatSummary<'a> {
+    fn new(results: &'a [FormatPathResult], mode: FormatMode) -> Self {
+        Self { results, mode }
+    }
+
+    /// Returns `true` if any of the files require formatting.
+    fn any_formatted(&self) -> bool {
+        self.results
+            .iter()
+            .any(|result| result.result.is_formatted())
     }
 }
 
-impl Display for FormatResultSummary {
+impl Display for FormatSummary<'_> {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        if self.formatted > 0 && self.unchanged > 0 {
+        // Compute the number of changed and unchanged files.
+        let mut formatted = 0u32;
+        let mut unchanged = 0u32;
+        for result in self.results {
+            match result.result {
+                FormatResult::Formatted => {
+                    // If we're running in check mode, report on any files that would be formatted.
+                    if self.mode.is_check() {
+                        writeln!(
+                            f,
+                            "Would reformat: {}",
+                            fs::relativize_path(&result.path).bold()
+                        )?;
+                    }
+                    formatted += 1;
+                }
+                FormatResult::Unchanged => unchanged += 1,
+            }
+        }
+
+        // Write out a summary of the formatting results.
+        if formatted > 0 && unchanged > 0 {
             write!(
                 f,
                 "{} file{} {}, {} file{} left unchanged",
-                self.formatted,
-                if self.formatted == 1 { "" } else { "s" },
+                formatted,
+                if formatted == 1 { "" } else { "s" },
                 match self.mode {
                     FormatMode::Write => "reformatted",
                     FormatMode::Check => "would be reformatted",
                 },
-                self.unchanged,
-                if self.unchanged == 1 { "" } else { "s" },
+                unchanged,
+                if unchanged == 1 { "" } else { "s" },
             )
-        } else if self.formatted > 0 {
+        } else if formatted > 0 {
             write!(
                 f,
                 "{} file{} {}",
-                self.formatted,
-                if self.formatted == 1 { "" } else { "s" },
+                formatted,
+                if formatted == 1 { "" } else { "s" },
                 match self.mode {
                     FormatMode::Write => "reformatted",
                     FormatMode::Check => "would be reformatted",
                 }
             )
-        } else if self.unchanged > 0 {
+        } else if unchanged > 0 {
             write!(
                 f,
                 "{} file{} left unchanged",
-                self.unchanged,
-                if self.unchanged == 1 { "" } else { "s" },
+                unchanged,
+                if unchanged == 1 { "" } else { "s" },
             )
         } else {
             Ok(())

crates/ruff_cli/src/commands/format_stdin.rs

@@ -2,7 +2,7 @@ use std::io::stdout;
 use std::path::Path;
 
 use anyhow::Result;
-use log::warn;
+use log::error;
 
 use ruff_linter::source_kind::SourceKind;
 use ruff_python_ast::{PySourceType, SourceType};
@@ -10,7 +10,7 @@ use ruff_workspace::resolver::python_file_at_path;
 use ruff_workspace::FormatterSettings;
 
 use crate::args::{CliOverrides, FormatArguments};
-use crate::commands::format::{format_source, FormatCommandError, FormatCommandResult, FormatMode};
+use crate::commands::format::{format_source, FormatCommandError, FormatMode, FormatResult};
 use crate::resolve::resolve;
 use crate::stdin::read_from_stdin;
 use crate::ExitStatus;
@@ -59,7 +59,7 @@ pub(crate) fn format_stdin(cli: &FormatArguments, overrides: &CliOverrides) -> R
             }
         },
         Err(err) => {
-            warn!("{err}");
+            error!("{err}");
             Ok(ExitStatus::Error)
         }
     }
@@ -71,14 +71,14 @@ fn format_source_code(
     settings: &FormatterSettings,
     source_type: PySourceType,
     mode: FormatMode,
-) -> Result<FormatCommandResult, FormatCommandError> {
+) -> Result<FormatResult, FormatCommandError> {
     // Read the source from stdin.
     let source_code = read_from_stdin()
         .map_err(|err| FormatCommandError::Read(path.map(Path::to_path_buf), err.into()))?;
 
     let source_kind = match SourceKind::from_source_code(source_code, source_type) {
         Ok(Some(source_kind)) => source_kind,
-        Ok(None) => return Ok(FormatCommandResult::Unchanged),
+        Ok(None) => return Ok(FormatResult::Unchanged),
         Err(err) => {
             return Err(FormatCommandError::Read(path.map(Path::to_path_buf), err));
         }
@@ -96,5 +96,5 @@ fn format_source_code(
             .map_err(|err| FormatCommandError::Write(path.map(Path::to_path_buf), err))?;
     }
 
-    Ok(FormatCommandResult::from(formatted))
+    Ok(FormatResult::from(formatted))
 }

crates/ruff_cli/src/commands/rule.rs

@@ -35,7 +35,7 @@ impl<'a> Explanation<'a> {
             message_formats: rule.message_formats(),
             fix,
             explanation: rule.explanation(),
-            preview: rule.is_preview(),
+            preview: rule.is_preview() || rule.is_nursery(),
         }
     }
 }
@@ -61,7 +61,7 @@ fn format_rule_text(rule: Rule) -> String {
         output.push('\n');
     }
 
-    if rule.is_preview() {
+    if rule.is_preview() || rule.is_nursery() {
         output.push_str(
             r#"This rule is in preview and is not stable. The `--preview` flag is required for use."#,
         );

crates/ruff_cli/src/diagnostics.rs

@@ -1,8 +1,7 @@
 #![cfg_attr(target_family = "wasm", allow(dead_code))]
 
-use std::fs::{write, File};
+use std::fs::File;
 use std::io;
-use std::io::{BufWriter, Write};
 use std::ops::AddAssign;
 #[cfg(unix)]
 use std::os::unix::fs::PermissionsExt;
@@ -12,8 +11,8 @@ use anyhow::{Context, Result};
 use colored::Colorize;
 use filetime::FileTime;
 use log::{debug, error, warn};
+use ruff_linter::settings::types::UnsafeFixes;
 use rustc_hash::FxHashMap;
-use similar::TextDiff;
 
 use ruff_diagnostics::Diagnostic;
 use ruff_linter::linter::{lint_fix, lint_only, FixTable, FixerResult, LinterResult};
@@ -25,7 +24,7 @@ use ruff_linter::settings::{flags, LinterSettings};
 use ruff_linter::source_kind::{SourceError, SourceKind};
 use ruff_linter::{fs, IOError, SyntaxError};
 use ruff_macros::CacheKey;
-use ruff_notebook::{Cell, Notebook, NotebookError, NotebookIndex};
+use ruff_notebook::{Notebook, NotebookError, NotebookIndex};
 use ruff_python_ast::imports::ImportMap;
 use ruff_python_ast::{SourceType, TomlSourceType};
 use ruff_source_file::{LineIndex, SourceCode, SourceFileBuilder};
@@ -170,6 +169,7 @@ pub(crate) fn lint_path(
     cache: Option<&Cache>,
     noqa: flags::Noqa,
     fix_mode: flags::FixMode,
+    unsafe_fixes: UnsafeFixes,
 ) -> Result<Diagnostics> {
     // Check the cache.
     // TODO(charlie): `fixer::Mode::Apply` and `fixer::Mode::Diff` both have
@@ -246,76 +246,24 @@ pub(crate) fn lint_path(
             result,
             transformed,
             fixed,
-        }) = lint_fix(path, package, noqa, settings, &source_kind, source_type)
-        {
+        }) = lint_fix(
+            path,
+            package,
+            noqa,
+            unsafe_fixes,
+            settings,
+            &source_kind,
+            source_type,
+        ) {
             if !fixed.is_empty() {
                 match fix_mode {
-                    flags::FixMode::Apply => match transformed.as_ref() {
-                        SourceKind::Python(transformed) => {
-                            write(path, transformed.as_bytes())?;
-                        }
-                        SourceKind::IpyNotebook(notebook) => {
-                            let mut writer = BufWriter::new(File::create(path)?);
-                            notebook.write(&mut writer)?;
-                        }
-                    },
+                    flags::FixMode::Apply => transformed.write(&mut File::create(path)?)?,
                     flags::FixMode::Diff => {
-                        match transformed.as_ref() {
-                            SourceKind::Python(transformed) => {
-                                let mut stdout = io::stdout().lock();
-                                TextDiff::from_lines(source_kind.source_code(), transformed)
-                                    .unified_diff()
-                                    .header(&fs::relativize_path(path), &fs::relativize_path(path))
-                                    .to_writer(&mut stdout)?;
-                                stdout.write_all(b"\n")?;
-                                stdout.flush()?;
-                            }
-                            SourceKind::IpyNotebook(dest_notebook) => {
-                                // We need to load the notebook again, since we might've
-                                // mutated it.
-                                let src_notebook = source_kind.as_ipy_notebook().unwrap();
-                                let mut stdout = io::stdout().lock();
-                                // Cell indices are 1-based.
-                                for ((idx, src_cell), dest_cell) in (1u32..)
-                                    .zip(src_notebook.cells().iter())
-                                    .zip(dest_notebook.cells().iter())
-                                {
-                                    let (Cell::Code(src_code_cell), Cell::Code(dest_code_cell)) =
-                                        (src_cell, dest_cell)
-                                    else {
-                                        continue;
-                                    };
-                                    TextDiff::from_lines(
-                                        &src_code_cell.source.to_string(),
-                                        &dest_code_cell.source.to_string(),
-                                    )
-                                    .unified_diff()
-                                    // Jupyter notebook cells don't necessarily have a newline
-                                    // at the end. For example,
-                                    //
-                                    // ```python
-                                    // print("hello")
-                                    // ```
-                                    //
-                                    // For a cell containing the above code, there'll only be one line,
-                                    // and it won't have a newline at the end. If it did, there'd be
-                                    // two lines, and the second line would be empty:
-                                    //
-                                    // ```python
-                                    // print("hello")
-                                    //
-                                    // ```
-                                    .missing_newline_hint(false)
-                                    .header(
-                                        &format!("{}:cell {}", &fs::relativize_path(path), idx),
-                                        &format!("{}:cell {}", &fs::relativize_path(path), idx),
-                                    )
-                                    .to_writer(&mut stdout)?;
-                                }
-                                stdout.write_all(b"\n")?;
-                                stdout.flush()?;
-                            }
-                        }
+                        source_kind.diff(
+                            transformed.as_ref(),
+                            Some(path),
+                            &mut io::stdout().lock(),
+                        )?;
                     }
                     flags::FixMode::Generate => {}
                 }
@@ -416,6 +364,7 @@ pub(crate) fn lint_stdin(
             path.unwrap_or_else(|| Path::new("-")),
             package,
             noqa,
+            settings.unsafe_fixes,
             &settings.linter,
             &source_kind,
             source_type,
@@ -428,20 +377,7 @@ pub(crate) fn lint_stdin(
                 flags::FixMode::Diff => {
                     // But only write a diff if it's non-empty.
                     if !fixed.is_empty() {
-                        let text_diff = TextDiff::from_lines(
-                            source_kind.source_code(),
-                            transformed.source_code(),
-                        );
-                        let mut unified_diff = text_diff.unified_diff();
-                        if let Some(path) = path {
-                            unified_diff
-                                .header(&fs::relativize_path(path), &fs::relativize_path(path));
-                        }
-
-                        let mut stdout = io::stdout().lock();
-                        unified_diff.to_writer(&mut stdout)?;
-                        stdout.write_all(b"\n")?;
-                        stdout.flush()?;
+                        source_kind.diff(transformed.as_ref(), path, &mut io::stdout().lock())?;
                     }
                 }
                 flags::FixMode::Generate => {}

crates/ruff_cli/src/lib.rs

@@ -6,11 +6,12 @@ use std::sync::mpsc::channel;
 
 use anyhow::Result;
 use clap::CommandFactory;
+use colored::Colorize;
 use log::warn;
 use notify::{recommended_watcher, RecursiveMode, Watcher};
 
 use ruff_linter::logging::{set_up_logging, LogLevel};
-use ruff_linter::settings::flags;
+use ruff_linter::settings::flags::FixMode;
 use ruff_linter::settings::types::SerializationFormat;
 use ruff_linter::{fs, warn_user, warn_user_once};
 use ruff_workspace::Settings;
@@ -104,8 +105,6 @@ pub fn run(
     }: Args,
 ) -> Result<ExitStatus> {
     {
-        use colored::Colorize;
-
         let default_panic_hook = std::panic::take_hook();
         std::panic::set_hook(Box::new(move |info| {
             #[allow(clippy::print_stderr)]
@@ -166,10 +165,7 @@ pub fn run(
 }
 
 fn format(args: FormatCommand, log_level: LogLevel) -> Result<ExitStatus> {
-    warn_user_once!(
-        "`ruff format` is a work-in-progress, subject to change at any time, and intended only for \
-        experimentation."
-    );
+    warn_user_once!("`ruff format` is not yet stable, and subject to change in future versions.");
 
     let (cli, overrides) = args.partition();
 
@@ -208,6 +204,7 @@ pub fn check(args: CheckCommand, log_level: LogLevel) -> Result<ExitStatus> {
         }
         _ => Box::new(BufWriter::new(io::stdout())),
     };
+    let stderr_writer = Box::new(BufWriter::new(io::stderr()));
 
     if cli.show_settings {
         commands::show_settings::show_settings(
@@ -228,6 +225,7 @@ pub fn check(args: CheckCommand, log_level: LogLevel) -> Result<ExitStatus> {
     let Settings {
         fix,
         fix_only,
+        unsafe_fixes,
         output_format,
         show_fixes,
         show_source,
@@ -236,17 +234,20 @@ pub fn check(args: CheckCommand, log_level: LogLevel) -> Result<ExitStatus> {
 
     // Fix rules are as follows:
     // - By default, generate all fixes, but don't apply them to the filesystem.
-    // - If `--fix` or `--fix-only` is set, always apply fixes to the filesystem (or
+    // - If `--fix` or `--fix-only` is set, apply applicable fixes to the filesystem (or
     //   print them to stdout, if we're reading from stdin).
-    // - If `--diff` or `--fix-only` are set, don't print any violations (only
-    //   fixes).
+    // - If `--diff` or `--fix-only` are set, don't print any violations (only applicable fixes)
+    // - By default, applicable fixes only include [`Applicablility::Automatic`], but if
+    //   `--unsafe-fixes` is set, then [`Applicablility::Suggested`] fixes are included.
+
     let fix_mode = if cli.diff {
-        flags::FixMode::Diff
+        FixMode::Diff
     } else if fix || fix_only {
-        flags::FixMode::Apply
+        FixMode::Apply
     } else {
-        flags::FixMode::Generate
+        FixMode::Generate
     };
+
     let cache = !cli.no_cache;
     let noqa = !cli.ignore_noqa;
     let mut printer_flags = PrinterFlags::empty();
@@ -290,11 +291,17 @@ pub fn check(args: CheckCommand, log_level: LogLevel) -> Result<ExitStatus> {
         return Ok(ExitStatus::Success);
     }
 
-    let printer = Printer::new(output_format, log_level, fix_mode, printer_flags);
+    let printer = Printer::new(
+        output_format,
+        log_level,
+        fix_mode,
+        unsafe_fixes,
+        printer_flags,
+    );
 
     if cli.watch {
         if output_format != SerializationFormat::Text {
-            warn_user!("--format 'text' is used in watch mode.");
+            warn_user!("`--output-format text` is always used in watch mode.");
         }
 
         // Configure the file watcher.
@@ -318,6 +325,7 @@ pub fn check(args: CheckCommand, log_level: LogLevel) -> Result<ExitStatus> {
             cache.into(),
             noqa.into(),
             fix_mode,
+            unsafe_fixes,
         )?;
         printer.write_continuously(&mut writer, &messages)?;
 
@@ -350,6 +358,7 @@ pub fn check(args: CheckCommand, log_level: LogLevel) -> Result<ExitStatus> {
                         cache.into(),
                         noqa.into(),
                         fix_mode,
+                        unsafe_fixes,
                     )?;
                     printer.write_continuously(&mut writer, &messages)?;
                 }
@@ -376,18 +385,22 @@ pub fn check(args: CheckCommand, log_level: LogLevel) -> Result<ExitStatus> {
                 cache.into(),
                 noqa.into(),
                 fix_mode,
+                unsafe_fixes,
             )?
         };
 
-        // Always try to print violations (the printer itself may suppress output),
-        // unless we're writing fixes via stdin (in which case, the transformed
-        // source code goes to stdout).
-        if !(is_stdin && matches!(fix_mode, flags::FixMode::Apply | flags::FixMode::Diff)) {
-            if cli.statistics {
-                printer.write_statistics(&diagnostics, &mut writer)?;
-            } else {
-                printer.write_once(&diagnostics, &mut writer)?;
-            }
+        // Always try to print violations (though the printer itself may suppress output)
+        // If we're writing fixes via stdin, the transformed source code goes to the writer
+        // so send the summary to stderr instead
+        let mut summary_writer = if is_stdin && matches!(fix_mode, FixMode::Apply | FixMode::Diff) {
+            stderr_writer
+        } else {
+            writer
+        };
+        if cli.statistics {
+            printer.write_statistics(&diagnostics, &mut summary_writer)?;
+        } else {
+            printer.write_once(&diagnostics, &mut summary_writer)?;
         }
 
         if !cli.exit_zero {

crates/ruff_cli/src/printer.rs

@@ -19,8 +19,8 @@ use ruff_linter::message::{
 };
 use ruff_linter::notify_user;
 use ruff_linter::registry::{AsRule, Rule};
-use ruff_linter::settings::flags;
-use ruff_linter::settings::types::SerializationFormat;
+use ruff_linter::settings::flags::{self};
+use ruff_linter::settings::types::{SerializationFormat, UnsafeFixes};
 
 use crate::diagnostics::Diagnostics;
 
@@ -73,6 +73,7 @@ pub(crate) struct Printer {
     format: SerializationFormat,
     log_level: LogLevel,
     fix_mode: flags::FixMode,
+    unsafe_fixes: UnsafeFixes,
     flags: Flags,
 }
 
@@ -81,12 +82,14 @@ impl Printer {
         format: SerializationFormat,
         log_level: LogLevel,
         fix_mode: flags::FixMode,
+        unsafe_fixes: UnsafeFixes,
         flags: Flags,
     ) -> Self {
         Self {
             format,
             log_level,
             fix_mode,
+            unsafe_fixes,
             flags,
         }
     }
@@ -99,12 +102,15 @@ impl Printer {
 
     fn write_summary_text(&self, writer: &mut dyn Write, diagnostics: &Diagnostics) -> Result<()> {
         if self.log_level >= LogLevel::Default {
+            let fixables = FixableStatistics::try_from(diagnostics, self.unsafe_fixes);
+
+            let fixed = diagnostics
+                .fixed
+                .values()
+                .flat_map(std::collections::HashMap::values)
+                .sum::<usize>();
+
             if self.flags.intersects(Flags::SHOW_VIOLATIONS) {
-                let fixed = diagnostics
-                    .fixed
-                    .values()
-                    .flat_map(std::collections::HashMap::values)
-                    .sum::<usize>();
                 let remaining = diagnostics.messages.len();
                 let total = fixed + remaining;
                 if fixed > 0 {
@@ -118,32 +124,83 @@ impl Printer {
                     writeln!(writer, "Found {remaining} error{s}.")?;
                 }
 
-                if show_fix_status(self.fix_mode) {
-                    let num_fixable = diagnostics
-                        .messages
-                        .iter()
-                        .filter(|message| message.fix.is_some())
-                        .count();
-                    if num_fixable > 0 {
-                        writeln!(
-                            writer,
-                            "[{}] {num_fixable} potentially fixable with the --fix option.",
-                            "*".cyan(),
-                        )?;
+                if let Some(fixables) = fixables {
+                    let fix_prefix = format!("[{}]", "*".cyan());
+
+                    if self.unsafe_fixes.is_enabled() {
+                        if fixables.applicable > 0 {
+                            writeln!(
+                                writer,
+                                "{fix_prefix} {} fixable with the --fix option.",
+                                fixables.applicable
+                            )?;
+                        }
+                    } else {
+                        if fixables.applicable > 0 && fixables.unapplicable_unsafe > 0 {
+                            let es = if fixables.unapplicable_unsafe == 1 {
+                                ""
+                            } else {
+                                "es"
+                            };
+                            writeln!(writer,
+                                "{fix_prefix} {} fixable with the `--fix` option ({} hidden fix{es} can be enabled with the `--unsafe-fixes` option).",
+                                fixables.applicable, fixables.unapplicable_unsafe
+                            )?;
+                        } else if fixables.applicable > 0 {
+                            // Only applicable fixes
+                            writeln!(
+                                writer,
+                                "{fix_prefix} {} fixable with the `--fix` option.",
+                                fixables.applicable,
+                            )?;
+                        } else {
+                            // Only unapplicable fixes
+                            let es = if fixables.unapplicable_unsafe == 1 {
+                                ""
+                            } else {
+                                "es"
+                            };
+                            writeln!(writer,
+                                "{} hidden fix{es} can be enabled with the `--unsafe-fixes` option.",
+                                fixables.unapplicable_unsafe
+                            )?;
+                        }
                     }
                 }
             } else {
-                let fixed = diagnostics
-                    .fixed
-                    .values()
-                    .flat_map(std::collections::HashMap::values)
-                    .sum::<usize>();
-                if fixed > 0 {
-                    let s = if fixed == 1 { "" } else { "s" };
-                    if self.fix_mode.is_apply() {
-                        writeln!(writer, "Fixed {fixed} error{s}.")?;
+                // Check if there are unapplied fixes
+                let unapplied = {
+                    if let Some(fixables) = fixables {
+                        fixables.unapplicable_unsafe
                     } else {
-                        writeln!(writer, "Would fix {fixed} error{s}.")?;
+                        0
+                    }
+                };
+
+                if unapplied > 0 {
+                    let es = if unapplied == 1 { "" } else { "es" };
+                    if fixed > 0 {
+                        let s = if fixed == 1 { "" } else { "s" };
+                        if self.fix_mode.is_apply() {
+                            writeln!(writer, "Fixed {fixed} error{s} ({unapplied} additional fix{es} available with `--unsafe-fixes`).")?;
+                        } else {
+                            writeln!(writer, "Would fix {fixed} error{s} ({unapplied} additional fix{es} available with `--unsafe-fixes`).")?;
+                        }
+                    } else {
+                        if self.fix_mode.is_apply() {
+                            writeln!(writer, "No errors fixed ({unapplied} fix{es} available with `--unsafe-fixes`).")?;
+                        } else {
+                            writeln!(writer, "No errors would be fixed ({unapplied} fix{es} available with `--unsafe-fixes`).")?;
+                        }
+                    }
+                } else {
+                    if fixed > 0 {
+                        let s = if fixed == 1 { "" } else { "s" };
+                        if self.fix_mode.is_apply() {
+                            writeln!(writer, "Fixed {fixed} error{s}.")?;
+                        } else {
+                            writeln!(writer, "Would fix {fixed} error{s}.")?;
+                        }
                     }
                 }
             }
@@ -178,6 +235,7 @@ impl Printer {
         }
 
         let context = EmitterContext::new(&diagnostics.notebook_indexes);
+        let fixables = FixableStatistics::try_from(diagnostics, self.unsafe_fixes);
 
         match self.format {
             SerializationFormat::Json => {
@@ -191,9 +249,10 @@ impl Printer {
             }
             SerializationFormat::Text => {
                 TextEmitter::default()
-                    .with_show_fix_status(show_fix_status(self.fix_mode))
+                    .with_show_fix_status(show_fix_status(self.fix_mode, fixables.as_ref()))
                     .with_show_fix_diff(self.flags.intersects(Flags::SHOW_FIX_DIFF))
                     .with_show_source(self.flags.intersects(Flags::SHOW_SOURCE))
+                    .with_unsafe_fixes(self.unsafe_fixes)
                     .emit(writer, &diagnostics.messages, &context)?;
 
                 if self.flags.intersects(Flags::SHOW_FIX_SUMMARY) {
@@ -209,7 +268,8 @@ impl Printer {
             SerializationFormat::Grouped => {
                 GroupedEmitter::default()
                     .with_show_source(self.flags.intersects(Flags::SHOW_SOURCE))
-                    .with_show_fix_status(show_fix_status(self.fix_mode))
+                    .with_show_fix_status(show_fix_status(self.fix_mode, fixables.as_ref()))
+                    .with_unsafe_fixes(self.unsafe_fixes)
                     .emit(writer, &diagnostics.messages, &context)?;
 
                 if self.flags.intersects(Flags::SHOW_FIX_SUMMARY) {
@@ -359,6 +419,8 @@ impl Printer {
             );
         }
 
+        let fixables = FixableStatistics::try_from(diagnostics, self.unsafe_fixes);
+
         if !diagnostics.messages.is_empty() {
             if self.log_level >= LogLevel::Default {
                 writeln!(writer)?;
@@ -366,8 +428,9 @@ impl Printer {
 
             let context = EmitterContext::new(&diagnostics.notebook_indexes);
             TextEmitter::default()
-                .with_show_fix_status(show_fix_status(self.fix_mode))
+                .with_show_fix_status(show_fix_status(self.fix_mode, fixables.as_ref()))
                 .with_show_source(self.flags.intersects(Flags::SHOW_SOURCE))
+                .with_unsafe_fixes(self.unsafe_fixes)
                 .emit(writer, &diagnostics.messages, &context)?;
         }
         writer.flush()?;
@@ -390,13 +453,13 @@ fn num_digits(n: usize) -> usize {
 }
 
 /// Return `true` if the [`Printer`] should indicate that a rule is fixable.
-const fn show_fix_status(fix_mode: flags::FixMode) -> bool {
+fn show_fix_status(fix_mode: flags::FixMode, fixables: Option<&FixableStatistics>) -> bool {
     // If we're in application mode, avoid indicating that a rule is fixable.
     // If the specific violation were truly fixable, it would've been fixed in
     // this pass! (We're occasionally unable to determine whether a specific
     // violation is fixable without trying to fix it, so if fix is not
     // enabled, we may inadvertently indicate that a rule is fixable.)
-    !fix_mode.is_apply()
+    (!fix_mode.is_apply()) && fixables.is_some_and(FixableStatistics::any_applicable_fixes)
 }
 
 fn print_fix_summary(writer: &mut dyn Write, fixed: &FxHashMap<String, FixTable>) -> Result<()> {
@@ -439,3 +502,43 @@ fn print_fix_summary(writer: &mut dyn Write, fixed: &FxHashMap<String, FixTable>
     }
     Ok(())
 }
+
+/// Statistics for [applicable][ruff_diagnostics::Applicability] fixes.
+#[derive(Debug)]
+struct FixableStatistics {
+    applicable: u32,
+    unapplicable_unsafe: u32,
+}
+
+impl FixableStatistics {
+    fn try_from(diagnostics: &Diagnostics, unsafe_fixes: UnsafeFixes) -> Option<Self> {
+        let mut applicable = 0;
+        let mut unapplicable_unsafe = 0;
+
+        for message in &diagnostics.messages {
+            if let Some(fix) = &message.fix {
+                if fix.applies(unsafe_fixes.required_applicability()) {
+                    applicable += 1;
+                } else {
+                    // Do not include unapplicable fixes at other levels that do not provide an opt-in
+                    if fix.applicability().is_unsafe() {
+                        unapplicable_unsafe += 1;
+                    }
+                }
+            }
+        }
+
+        if applicable == 0 && unapplicable_unsafe == 0 {
+            None
+        } else {
+            Some(Self {
+                applicable,
+                unapplicable_unsafe,
+            })
+        }
+    }
+
+    fn any_applicable_fixes(&self) -> bool {
+        self.applicable > 0
+    }
+}

crates/ruff_cli/tests/format.rs

@@ -39,7 +39,7 @@ if condition:
         print('Hy "Micha"')  # Should not change quotes
 
     ----- stderr -----
-    warning: `ruff format` is a work-in-progress, subject to change at any time, and intended only for experimentation.
+    warning: `ruff format` is not yet stable, and subject to change in future versions.
     "###);
 }
 
@@ -83,7 +83,7 @@ if condition:
     	print('Should change quotes')
 
     ----- stderr -----
-    warning: `ruff format` is a work-in-progress, subject to change at any time, and intended only for experimentation.
+    warning: `ruff format` is not yet stable, and subject to change in future versions.
     "###);
     Ok(())
 }
@@ -139,7 +139,7 @@ if condition:
     	print('Should change quotes')
 
     ----- stderr -----
-    warning: `ruff format` is a work-in-progress, subject to change at any time, and intended only for experimentation.
+    warning: `ruff format` is not yet stable, and subject to change in future versions.
     "###);
     Ok(())
 }
@@ -168,6 +168,7 @@ import os
     ----- stdout -----
     [
       {
+        "cell": null,
         "code": "F401",
         "end_location": {
           "column": 10,
@@ -175,7 +176,7 @@ import os
         },
         "filename": "-",
         "fix": {
-          "applicability": "Automatic",
+          "applicability": "safe",
           "edits": [
             {
               "content": "",

crates/ruff_cli/tests/integration_test.rs

@@ -1,6 +1,5 @@
 #![cfg(not(target_family = "wasm"))]
 
-#[cfg(unix)]
 use std::fs;
 #[cfg(unix)]
 use std::fs::Permissions;
@@ -12,13 +11,13 @@ use std::process::Command;
 use std::str;
 
 #[cfg(unix)]
-use anyhow::{Context, Result};
+use anyhow::Context;
+use anyhow::Result;
 #[cfg(unix)]
 use clap::Parser;
 use insta_cmd::{assert_cmd_snapshot, get_cargo_bin};
 #[cfg(unix)]
 use path_absolutize::path_dedot;
-#[cfg(unix)]
 use tempfile::TempDir;
 
 #[cfg(unix)]
@@ -46,16 +45,16 @@ fn stdin_success() {
 fn stdin_error() {
     assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME))
         .args(STDIN_BASE_OPTIONS)
-        .pass_stdin("import os\n"), @r#"
+        .pass_stdin("import os\n"), @r###"
     success: false
     exit_code: 1
     ----- stdout -----
     -:1:8: F401 [*] `os` imported but unused
     Found 1 error.
-    [*] 1 potentially fixable with the --fix option.
+    [*] 1 fixable with the `--fix` option.
 
     ----- stderr -----
-    "#);
+    "###);
 }
 
 #[test]
@@ -69,7 +68,7 @@ fn stdin_filename() {
     ----- stdout -----
     F401.py:1:8: F401 [*] `os` imported but unused
     Found 1 error.
-    [*] 1 potentially fixable with the --fix option.
+    [*] 1 fixable with the `--fix` option.
 
     ----- stderr -----
     "###);
@@ -87,7 +86,7 @@ fn stdin_source_type_py() {
     ----- stdout -----
     TCH.py:1:8: F401 [*] `os` imported but unused
     Found 1 error.
-    [*] 1 potentially fixable with the --fix option.
+    [*] 1 fixable with the `--fix` option.
 
     ----- stderr -----
     "###);
@@ -150,6 +149,7 @@ fn stdin_fix_py() {
     print(sys.version)
 
     ----- stderr -----
+    Found 1 error (1 fixed, 0 remaining).
     "###);
 }
 
@@ -317,6 +317,7 @@ fn stdin_fix_jupyter() {
      "nbformat_minor": 5
     }
     ----- stderr -----
+    Found 2 errors (2 fixed, 0 remaining).
     "###);
 }
 
@@ -336,6 +337,8 @@ fn stdin_fix_when_not_fixable_should_still_print_contents() {
          print(sys.version)
 
     ----- stderr -----
+    -:3:4: F634 If test is a tuple, which is always `True`
+    Found 2 errors (1 fixed, 1 remaining).
     "###);
 }
 
@@ -482,7 +485,7 @@ fn stdin_format_jupyter() {
     }
 
     ----- stderr -----
-    warning: `ruff format` is a work-in-progress, subject to change at any time, and intended only for experimentation.
+    warning: `ruff format` is not yet stable, and subject to change in future versions.
     "###);
 }
 
@@ -733,6 +736,42 @@ fn preview_disabled_prefix_empty() {
     "###);
 }
 
+#[test]
+fn preview_disabled_does_not_warn_for_empty_ignore_selections() {
+    // Does not warn that the selection is empty since the user is not trying to enable the rule
+    let args = ["--ignore", "CPY"];
+    assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME))
+        .args(STDIN_BASE_OPTIONS)
+        .args(args)
+        .pass_stdin("I=42\n"), @r###"
+    success: false
+    exit_code: 1
+    ----- stdout -----
+    -:1:1: E741 Ambiguous variable name: `I`
+    Found 1 error.
+
+    ----- stderr -----
+    "###);
+}
+
+#[test]
+fn preview_disabled_does_not_warn_for_empty_fixable_selections() {
+    // Does not warn that the selection is empty since the user is not trying to enable the rule
+    let args = ["--fixable", "CPY"];
+    assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME))
+        .args(STDIN_BASE_OPTIONS)
+        .args(args)
+        .pass_stdin("I=42\n"), @r###"
+    success: false
+    exit_code: 1
+    ----- stdout -----
+    -:1:1: E741 Ambiguous variable name: `I`
+    Found 1 error.
+
+    ----- stderr -----
+    "###);
+}
+
 #[test]
 fn preview_group_selector() {
     // `--select PREVIEW` should error (selector was removed)
@@ -861,7 +900,7 @@ fn check_input_from_argfile() -> Result<()> {
         ----- stdout -----
         /path/to/a.py:1:8: F401 [*] `os` imported but unused
         Found 1 error.
-        [*] 1 potentially fixable with the --fix option.
+        [*] 1 fixable with the `--fix` option.
 
         ----- stderr -----
         "###);
@@ -869,3 +908,499 @@ fn check_input_from_argfile() -> Result<()> {
 
     Ok(())
 }
+
+#[test]
+fn check_hints_hidden_unsafe_fixes() {
+    assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME))
+        .args([
+            "-",
+            "--output-format=text",
+            "--isolated",
+            "--select",
+            "F601,UP034",
+            "--no-cache",
+        ])
+        .pass_stdin("x = {'a': 1, 'a': 1}\nprint(('foo'))\n"),
+        @r###"
+    success: false
+    exit_code: 1
+    ----- stdout -----
+    -:1:14: F601 Dictionary key literal `'a'` repeated
+    -:2:7: UP034 [*] Avoid extraneous parentheses
+    Found 2 errors.
+    [*] 1 fixable with the `--fix` option (1 hidden fix can be enabled with the `--unsafe-fixes` option).
+
+    ----- stderr -----
+    "###);
+}
+
+#[test]
+fn check_hints_hidden_unsafe_fixes_with_no_safe_fixes() {
+    assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME))
+        .args(["-", "--output-format", "text", "--no-cache", "--isolated", "--select", "F601"])
+        .pass_stdin("x = {'a': 1, 'a': 1}\n"),
+        @r###"
+    success: false
+    exit_code: 1
+    ----- stdout -----
+    -:1:14: F601 Dictionary key literal `'a'` repeated
+    Found 1 error.
+    1 hidden fix can be enabled with the `--unsafe-fixes` option.
+
+    ----- stderr -----
+    "###);
+}
+
+#[test]
+fn check_shows_unsafe_fixes_with_opt_in() {
+    assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME))
+        .args([
+            "-",
+            "--output-format=text",
+            "--isolated",
+            "--select",
+            "F601,UP034",
+            "--no-cache",
+            "--unsafe-fixes",
+        ])
+        .pass_stdin("x = {'a': 1, 'a': 1}\nprint(('foo'))\n"),
+        @r###"
+    success: false
+    exit_code: 1
+    ----- stdout -----
+    -:1:14: F601 [*] Dictionary key literal `'a'` repeated
+    -:2:7: UP034 [*] Avoid extraneous parentheses
+    Found 2 errors.
+    [*] 2 fixable with the --fix option.
+
+    ----- stderr -----
+    "###);
+}
+
+#[test]
+fn fix_applies_safe_fixes_by_default() {
+    assert_cmd_snapshot!(
+        Command::new(get_cargo_bin(BIN_NAME))
+            .args([
+                "-",
+                "--output-format",
+                "text",
+                "--isolated",
+                "--no-cache",
+                "--select",
+                "F601,UP034",
+                "--fix",
+            ])
+            .pass_stdin("x = {'a': 1, 'a': 1}\nprint(('foo'))\n"),
+            @r###"
+    success: false
+    exit_code: 1
+    ----- stdout -----
+    x = {'a': 1, 'a': 1}
+    print('foo')
+
+    ----- stderr -----
+    -:1:14: F601 Dictionary key literal `'a'` repeated
+    Found 2 errors (1 fixed, 1 remaining).
+    1 hidden fix can be enabled with the `--unsafe-fixes` option.
+    "###);
+}
+
+#[test]
+fn fix_applies_unsafe_fixes_with_opt_in() {
+    assert_cmd_snapshot!(
+        Command::new(get_cargo_bin(BIN_NAME))
+            .args([
+                "-",
+                "--output-format",
+                "text",
+                "--isolated",
+                "--no-cache",
+                "--select",
+                "F601,UP034",
+                "--fix",
+                "--unsafe-fixes",
+            ])
+            .pass_stdin("x = {'a': 1, 'a': 1}\nprint(('foo'))\n"),
+            @r###"
+    success: true
+    exit_code: 0
+    ----- stdout -----
+    x = {'a': 1}
+    print('foo')
+
+    ----- stderr -----
+    Found 2 errors (2 fixed, 0 remaining).
+    "###);
+}
+
+#[test]
+fn fix_does_not_apply_display_only_fixes() {
+    assert_cmd_snapshot!(
+        Command::new(get_cargo_bin(BIN_NAME))
+            .args([
+                "-",
+                "--output-format",
+                "text",
+                "--isolated",
+                "--no-cache",
+                "--select",
+                "B006",
+                "--fix",
+            ])
+            .pass_stdin("def add_to_list(item, some_list=[]): ..."),
+            @r###"
+    success: false
+    exit_code: 1
+    ----- stdout -----
+    def add_to_list(item, some_list=[]): ...
+    ----- stderr -----
+    -:1:33: B006 Do not use mutable data structures for argument defaults
+    Found 1 error.
+    "###);
+}
+
+#[test]
+fn fix_does_not_apply_display_only_fixes_with_unsafe_fixes_enabled() {
+    assert_cmd_snapshot!(
+        Command::new(get_cargo_bin(BIN_NAME))
+            .args([
+                "-",
+                "--output-format",
+                "text",
+                "--isolated",
+                "--no-cache",
+                "--select",
+                "B006",
+                "--fix",
+                "--unsafe-fixes",
+            ])
+            .pass_stdin("def add_to_list(item, some_list=[]): ..."),
+            @r###"
+    success: false
+    exit_code: 1
+    ----- stdout -----
+    def add_to_list(item, some_list=[]): ...
+    ----- stderr -----
+    -:1:33: B006 Do not use mutable data structures for argument defaults
+    Found 1 error.
+    "###);
+}
+
+#[test]
+fn fix_only_unsafe_fixes_available() {
+    assert_cmd_snapshot!(
+        Command::new(get_cargo_bin(BIN_NAME))
+            .args([
+                "-",
+                "--output-format",
+                "text",
+                "--isolated",
+                "--no-cache",
+                "--select",
+                "F601",
+                "--fix",
+            ])
+            .pass_stdin("x = {'a': 1, 'a': 1}\nprint(('foo'))\n"),
+            @r###"
+    success: false
+    exit_code: 1
+    ----- stdout -----
+    x = {'a': 1, 'a': 1}
+    print(('foo'))
+
+    ----- stderr -----
+    -:1:14: F601 Dictionary key literal `'a'` repeated
+    Found 1 error.
+    1 hidden fix can be enabled with the `--unsafe-fixes` option.
+    "###);
+}
+
+#[test]
+fn fix_only_flag_applies_safe_fixes_by_default() {
+    assert_cmd_snapshot!(
+        Command::new(get_cargo_bin(BIN_NAME))
+            .args([
+                "-",
+                "--output-format",
+                "text",
+                "--isolated",
+                "--no-cache",
+                "--select",
+                "F601,UP034",
+                "--fix-only",
+            ])
+            .pass_stdin("x = {'a': 1, 'a': 1}\nprint(('foo'))\n"),
+            @r###"
+    success: true
+    exit_code: 0
+    ----- stdout -----
+    x = {'a': 1, 'a': 1}
+    print('foo')
+
+    ----- stderr -----
+    Fixed 1 error (1 additional fix available with `--unsafe-fixes`).
+    "###);
+}
+
+#[test]
+fn fix_only_flag_applies_unsafe_fixes_with_opt_in() {
+    assert_cmd_snapshot!(
+        Command::new(get_cargo_bin(BIN_NAME))
+            .args([
+                "-",
+                "--output-format",
+                "text",
+                "--isolated",
+                "--no-cache",
+                "--select",
+                "F601,UP034",
+                "--fix-only",
+                "--unsafe-fixes",
+            ])
+            .pass_stdin("x = {'a': 1, 'a': 1}\nprint(('foo'))\n"),
+            @r###"
+    success: true
+    exit_code: 0
+    ----- stdout -----
+    x = {'a': 1}
+    print('foo')
+
+    ----- stderr -----
+    Fixed 2 errors.
+    "###);
+}
+
+#[test]
+fn diff_shows_safe_fixes_by_default() {
+    assert_cmd_snapshot!(
+    Command::new(get_cargo_bin(BIN_NAME))
+        .args([
+            "-",
+            "--output-format",
+            "text",
+            "--isolated",
+            "--no-cache",
+            "--select",
+            "F601,UP034",
+            "--diff",
+        ])
+        .pass_stdin("x = {'a': 1, 'a': 1}\nprint(('foo'))\n"),
+        @r###"
+    success: false
+    exit_code: 1
+    ----- stdout -----
+    @@ -1,2 +1,2 @@
+     x = {'a': 1, 'a': 1}
+    -print(('foo'))
+    +print('foo')
+
+
+    ----- stderr -----
+    Would fix 1 error (1 additional fix available with `--unsafe-fixes`).
+    "###
+    );
+}
+
+#[test]
+fn diff_shows_unsafe_fixes_with_opt_in() {
+    assert_cmd_snapshot!(
+        Command::new(get_cargo_bin(BIN_NAME))
+            .args([
+                "-",
+                "--output-format",
+                "text",
+                "--isolated",
+                "--no-cache",
+                "--select",
+                "F601,UP034",
+                "--diff",
+                "--unsafe-fixes",
+            ])
+            .pass_stdin("x = {'a': 1, 'a': 1}\nprint(('foo'))\n"),
+            @r###"
+    success: false
+    exit_code: 1
+    ----- stdout -----
+    @@ -1,2 +1,2 @@
+    -x = {'a': 1, 'a': 1}
+    -print(('foo'))
+    +x = {'a': 1}
+    +print('foo')
+
+
+    ----- stderr -----
+    Would fix 2 errors.
+    "###
+    );
+}
+
+#[test]
+fn diff_does_not_show_display_only_fixes_with_unsafe_fixes_enabled() {
+    assert_cmd_snapshot!(
+        Command::new(get_cargo_bin(BIN_NAME))
+            .args([
+                "-",
+                "--output-format",
+                "text",
+                "--isolated",
+                "--no-cache",
+                "--select",
+                "B006",
+                "--diff",
+                "--unsafe-fixes",
+            ])
+            .pass_stdin("def add_to_list(item, some_list=[]): ..."),
+            @r###"
+    success: false
+    exit_code: 1
+    ----- stdout -----
+
+    ----- stderr -----
+    "###);
+}
+
+#[test]
+fn diff_only_unsafe_fixes_available() {
+    assert_cmd_snapshot!(
+    Command::new(get_cargo_bin(BIN_NAME))
+        .args([
+            "-",
+            "--output-format",
+            "text",
+            "--isolated",
+            "--no-cache",
+            "--select",
+            "F601",
+            "--diff",
+        ])
+        .pass_stdin("x = {'a': 1, 'a': 1}\nprint(('foo'))\n"),
+        @r###"
+    success: false
+    exit_code: 1
+    ----- stdout -----
+
+    ----- stderr -----
+    No errors would be fixed (1 fix available with `--unsafe-fixes`).
+    "###
+    );
+}
+
+#[test]
+fn check_extend_unsafe_fixes() -> Result<()> {
+    let tempdir = TempDir::new()?;
+    let ruff_toml = tempdir.path().join("ruff.toml");
+    fs::write(
+        &ruff_toml,
+        r#"
+[lint]
+extend-unsafe-fixes = ["UP034"]
+"#,
+    )?;
+
+    assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME))
+        .args(["check", "--config"])
+        .arg(&ruff_toml)
+        .arg("-")
+        .args([
+            "--output-format",
+            "text",
+            "--no-cache", 
+            "--select",
+            "F601,UP034",
+        ])
+        .pass_stdin("x = {'a': 1, 'a': 1}\nprint(('foo'))\n"),
+            @r###"
+    success: false
+    exit_code: 1
+    ----- stdout -----
+    -:1:14: F601 Dictionary key literal `'a'` repeated
+    -:2:7: UP034 Avoid extraneous parentheses
+    Found 2 errors.
+    2 hidden fixes can be enabled with the `--unsafe-fixes` option.
+
+    ----- stderr -----
+    "###);
+
+    Ok(())
+}
+
+#[test]
+fn check_extend_safe_fixes() -> Result<()> {
+    let tempdir = TempDir::new()?;
+    let ruff_toml = tempdir.path().join("ruff.toml");
+    fs::write(
+        &ruff_toml,
+        r#"
+[lint]
+extend-safe-fixes = ["F601"]
+"#,
+    )?;
+
+    assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME))
+        .args(["check", "--config"])
+        .arg(&ruff_toml)
+        .arg("-")
+        .args([
+            "--output-format",
+            "text",
+            "--no-cache", 
+            "--select",
+            "F601,UP034",
+        ])
+        .pass_stdin("x = {'a': 1, 'a': 1}\nprint(('foo'))\n"),
+            @r###"
+    success: false
+    exit_code: 1
+    ----- stdout -----
+    -:1:14: F601 [*] Dictionary key literal `'a'` repeated
+    -:2:7: UP034 [*] Avoid extraneous parentheses
+    Found 2 errors.
+    [*] 2 fixable with the `--fix` option.
+
+    ----- stderr -----
+    "###);
+
+    Ok(())
+}
+
+#[test]
+fn check_extend_unsafe_fixes_conflict_with_extend_safe_fixes() -> Result<()> {
+    // Adding a rule to both options should result in it being treated as unsafe
+    let tempdir = TempDir::new()?;
+    let ruff_toml = tempdir.path().join("ruff.toml");
+    fs::write(
+        &ruff_toml,
+        r#"
+[lint]
+extend-unsafe-fixes = ["UP034"]
+extend-safe-fixes = ["UP034"]
+"#,
+    )?;
+
+    assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME))
+        .args(["check", "--config"])
+        .arg(&ruff_toml)
+        .arg("-")
+        .args([
+            "--output-format",
+            "text",
+            "--no-cache",
+            "--select",
+            "F601,UP034",
+        ])
+        .pass_stdin("x = {'a': 1, 'a': 1}\nprint(('foo'))\n"),
+            @r###"
+    success: false
+    exit_code: 1
+    ----- stdout -----
+    -:1:14: F601 Dictionary key literal `'a'` repeated
+    -:2:7: UP034 Avoid extraneous parentheses
+    Found 2 errors.
+    2 hidden fixes can be enabled with the `--unsafe-fixes` option.
+
+    ----- stderr -----
+    "###);
+
+    Ok(())
+}

crates/ruff_cli/tests/lint.rs

@@ -40,7 +40,7 @@ inline-quotes = "single"
     -:1:5: B005 Using `.strip()` with multi-character strings is misleading
     -:1:19: Q000 [*] Double quotes found but single quotes preferred
     Found 3 errors.
-    [*] 2 potentially fixable with the --fix option.
+    [*] 2 fixable with the `--fix` option.
 
     ----- stderr -----
     "###);
@@ -75,7 +75,7 @@ inline-quotes = "single"
     -:1:5: B005 Using `.strip()` with multi-character strings is misleading
     -:1:19: Q000 [*] Double quotes found but single quotes preferred
     Found 3 errors.
-    [*] 2 potentially fixable with the --fix option.
+    [*] 2 fixable with the `--fix` option.
 
     ----- stderr -----
     "###);
@@ -110,7 +110,7 @@ inline-quotes = "single"
     -:1:5: B005 Using `.strip()` with multi-character strings is misleading
     -:1:19: Q000 [*] Double quotes found but single quotes preferred
     Found 3 errors.
-    [*] 2 potentially fixable with the --fix option.
+    [*] 2 fixable with the `--fix` option.
 
     ----- stderr -----
     "###);
@@ -149,7 +149,7 @@ inline-quotes = "single"
     -:1:5: B005 Using `.strip()` with multi-character strings is misleading
     -:1:19: Q000 [*] Double quotes found but single quotes preferred
     Found 3 errors.
-    [*] 2 potentially fixable with the --fix option.
+    [*] 2 fixable with the `--fix` option.
 
     ----- stderr -----
     "###);

crates/ruff_cli/tests/snapshots/integration_test__stdin_json.snap

@@ -17,6 +17,7 @@ exit_code: 1
 ----- stdout -----
 [
   {
+    "cell": null,
     "code": "F401",
     "end_location": {
       "column": 10,
@@ -24,7 +25,7 @@ exit_code: 1
     },
     "filename": "/path/to/F401.py",
     "fix": {
-      "applicability": "Automatic",
+      "applicability": "safe",
       "edits": [
         {
           "content": "",

crates/ruff_diagnostics/Cargo.toml

@@ -17,4 +17,5 @@ ruff_text_size = { path = "../ruff_text_size" }
 
 anyhow = { workspace = true }
 log = { workspace = true }
+is-macro = { workspace = true }
 serde = { workspace = true, optional = true, features = [] }

crates/ruff_diagnostics/src/fix.rs

@@ -5,27 +5,22 @@ use ruff_text_size::{Ranged, TextSize};
 
 use crate::edit::Edit;
 
-/// Indicates confidence in the correctness of a suggested fix.
-#[derive(Default, Copy, Clone, Debug, Hash, PartialEq, Eq, PartialOrd, Ord)]
+/// Indicates if a fix can be applied.
+#[derive(Copy, Clone, Debug, Hash, PartialEq, Eq, PartialOrd, Ord, is_macro::Is)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "serde", serde(rename_all = "lowercase"))]
 pub enum Applicability {
-    /// The fix is definitely what the user intended, or maintains the exact meaning of the code.
-    /// This fix should be automatically applied.
-    Automatic,
+    /// The fix is unsafe and should only be displayed for manual application by the user.
+    /// The fix is likely to be incorrect or the resulting code may have invalid syntax.
+    Display,
 
-    /// The fix may be what the user intended, but it is uncertain.
-    /// The fix should result in valid code if it is applied.
-    /// The fix can be applied with user opt-in.
-    Suggested,
+    /// The fix is unsafe and should only be applied with user opt-in.
+    /// The fix may be what the user intended, but it is uncertain; the resulting code will have valid syntax.
+    Unsafe,
 
-    /// The fix has a good chance of being incorrect or the code be incomplete.
-    /// The fix may result in invalid code if it is applied.
-    /// The fix should only be manually applied by the user.
-    Manual,
-
-    /// The applicability of the fix is unknown.
-    #[default]
-    Unspecified,
+    /// The fix is safe and can always be applied.
+    /// The fix is definitely what the user intended, or it maintains the exact meaning of the code.
+    Safe,
 }
 
 /// Indicates the level of isolation required to apply a fix.
@@ -52,86 +47,62 @@ pub struct Fix {
 }
 
 impl Fix {
-    /// Create a new [`Fix`] with an unspecified applicability from an [`Edit`] element.
-    #[deprecated(
-        note = "Use `Fix::automatic`, `Fix::suggested`, or `Fix::manual` instead to specify an applicability."
-    )]
-    pub fn unspecified(edit: Edit) -> Self {
+    /// Create a new [`Fix`] that is [safe](Applicability::Safe) to apply from an [`Edit`] element.
+    pub fn safe_edit(edit: Edit) -> Self {
         Self {
             edits: vec![edit],
-            applicability: Applicability::Unspecified,
+            applicability: Applicability::Safe,
             isolation_level: IsolationLevel::default(),
         }
     }
 
-    /// Create a new [`Fix`] with an unspecified applicability from multiple [`Edit`] elements.
-    #[deprecated(
-        note = "Use `Fix::automatic_edits`, `Fix::suggested_edits`, or `Fix::manual_edits` instead to specify an applicability."
-    )]
-    pub fn unspecified_edits(edit: Edit, rest: impl IntoIterator<Item = Edit>) -> Self {
-        Self {
-            edits: std::iter::once(edit).chain(rest).collect(),
-            applicability: Applicability::Unspecified,
-            isolation_level: IsolationLevel::default(),
-        }
-    }
-
-    /// Create a new [`Fix`] with [automatic applicability](Applicability::Automatic) from an [`Edit`] element.
-    pub fn automatic(edit: Edit) -> Self {
-        Self {
-            edits: vec![edit],
-            applicability: Applicability::Automatic,
-            isolation_level: IsolationLevel::default(),
-        }
-    }
-
-    /// Create a new [`Fix`] with [automatic applicability](Applicability::Automatic) from multiple [`Edit`] elements.
-    pub fn automatic_edits(edit: Edit, rest: impl IntoIterator<Item = Edit>) -> Self {
+    /// Create a new [`Fix`] that is [safe](Applicability::Safe) to apply from multiple [`Edit`] elements.
+    pub fn safe_edits(edit: Edit, rest: impl IntoIterator<Item = Edit>) -> Self {
         let mut edits: Vec<Edit> = std::iter::once(edit).chain(rest).collect();
         edits.sort_by_key(|edit| (edit.start(), edit.end()));
         Self {
             edits,
-            applicability: Applicability::Automatic,
+            applicability: Applicability::Safe,
             isolation_level: IsolationLevel::default(),
         }
     }
 
-    /// Create a new [`Fix`] with [suggested applicability](Applicability::Suggested) from an [`Edit`] element.
-    pub fn suggested(edit: Edit) -> Self {
+    /// Create a new [`Fix`] that is [unsafe](Applicability::Unsafe) to apply from an [`Edit`] element.
+    pub fn unsafe_edit(edit: Edit) -> Self {
         Self {
             edits: vec![edit],
-            applicability: Applicability::Suggested,
+            applicability: Applicability::Unsafe,
             isolation_level: IsolationLevel::default(),
         }
     }
 
-    /// Create a new [`Fix`] with [suggested applicability](Applicability::Suggested) from multiple [`Edit`] elements.
-    pub fn suggested_edits(edit: Edit, rest: impl IntoIterator<Item = Edit>) -> Self {
+    /// Create a new [`Fix`] that is [unsafe](Applicability::Unsafe) to apply from multiple [`Edit`] elements.
+    pub fn unsafe_edits(edit: Edit, rest: impl IntoIterator<Item = Edit>) -> Self {
         let mut edits: Vec<Edit> = std::iter::once(edit).chain(rest).collect();
         edits.sort_by_key(|edit| (edit.start(), edit.end()));
         Self {
             edits,
-            applicability: Applicability::Suggested,
+            applicability: Applicability::Unsafe,
             isolation_level: IsolationLevel::default(),
         }
     }
 
-    /// Create a new [`Fix`] with [manual applicability](Applicability::Manual) from an [`Edit`] element.
-    pub fn manual(edit: Edit) -> Self {
+    /// Create a new [`Fix`] that should only [display](Applicability::Display) and not apply from an [`Edit`] element .
+    pub fn display_edit(edit: Edit) -> Self {
         Self {
             edits: vec![edit],
-            applicability: Applicability::Manual,
+            applicability: Applicability::Display,
             isolation_level: IsolationLevel::default(),
         }
     }
 
-    /// Create a new [`Fix`] with [manual applicability](Applicability::Manual) from multiple [`Edit`] elements.
-    pub fn manual_edits(edit: Edit, rest: impl IntoIterator<Item = Edit>) -> Self {
+    /// Create a new [`Fix`] that should only [display](Applicability::Display) and not apply from multiple [`Edit`] elements.
+    pub fn display_edits(edit: Edit, rest: impl IntoIterator<Item = Edit>) -> Self {
         let mut edits: Vec<Edit> = std::iter::once(edit).chain(rest).collect();
         edits.sort_by_key(|edit| (edit.start(), edit.end()));
         Self {
             edits,
-            applicability: Applicability::Manual,
+            applicability: Applicability::Display,
             isolation_level: IsolationLevel::default(),
         }
     }
@@ -162,4 +133,16 @@ impl Fix {
         self.isolation_level = isolation;
         self
     }
+
+    /// Return [`true`] if this [`Fix`] should be applied with at a given [`Applicability`].
+    pub fn applies(&self, applicability: Applicability) -> bool {
+        self.applicability >= applicability
+    }
+
+    /// Create a new [`Fix`] with the given [`Applicability`].
+    #[must_use]
+    pub fn with_applicability(mut self, applicability: Applicability) -> Self {
+        self.applicability = applicability;
+        self
+    }
 }

crates/ruff_formatter/Cargo.toml

@@ -20,7 +20,7 @@ rustc-hash = { workspace = true }
 schemars = { workspace = true, optional = true }
 serde = { workspace = true, optional = true }
 static_assertions = { workspace = true }
-tracing = { version = "0.1.37", default-features = false, features = ["std"] }
+tracing = { workspace = true }
 unicode-width = { workspace = true }
 
 [dev-dependencies]

crates/ruff_linter/Cargo.toml

@@ -70,7 +70,7 @@ thiserror = { workspace = true }
 toml = { workspace = true }
 typed-arena = { version = "2.0.2" }
 unicode-width = { workspace = true }
-unicode_names2 = { version = "0.6.0", git = "https://github.com/youknowone/unicode_names2.git", rev = "4ce16aa85cbcdd9cc830410f1a72ef9a235f2fde" }
+unicode_names2 = { workspace = true }
 wsl = { version = "0.1.0" }
 
 [dev-dependencies]

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

@@ -70,6 +70,8 @@ settings.set_enable_developer_extras(True)
 foo.is_(True)
 bar.is_not(False)
 next(iter([]), False)
+sa.func.coalesce(tbl.c.valid, False)
+
 
 class Registry:
     def __init__(self) -> None:

crates/ruff_linter/resources/test/fixtures/flake8_comprehensions/C414.py

@@ -32,3 +32,16 @@ sorted(sorted(x, key=lambda y: y))
 sorted(sorted(x, key=lambda y: y), key=lambda x: x)
 sorted(sorted(x), reverse=True)
 sorted(sorted(x, reverse=False), reverse=True)
+
+# Preserve trailing comments.
+xxxxxxxxxxx_xxxxx_xxxxx = sorted(
+    list(x_xxxx_xxxxxxxxxxx_xxxxx.xxxx()),
+    # xxxxxxxxxxx xxxxx xxxx xxx xx Nxxx, xxx xxxxxx3 xxxxxxxxx xx
+    # xx xxxx xxxxxxx xxxx xxx xxxxxxxx Nxxx
+    key=lambda xxxxx: xxxxx or "",
+)
+
+xxxxxxxxxxx_xxxxx_xxxxx = sorted(
+    list(x_xxxx_xxxxxxxxxxx_xxxxx.xxxx()),  # xxxxxxxxxxx xxxxx xxxx xxx xx Nxxx
+    key=lambda xxxxx: xxxxx or "",
+)

crates/ruff_linter/resources/test/fixtures/flake8_pie/PIE804.py

@@ -8,6 +8,8 @@ Foo.objects.create(**{"_id": some_id})  # PIE804
 
 Foo.objects.create(**{**bar})  # PIE804
 
+foo(**{})
+
 
 foo(**{**data, "foo": "buzz"})
 foo(**buzz)

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

@@ -28,4 +28,12 @@ item: type[requests_mock.Mocker] | type[httpretty] = requests_mock.Mocker
 
 def func():
     # PYI055
-    item: type[requests_mock.Mocker] | type[httpretty] = requests_mock.Mocker
+    x: type[requests_mock.Mocker] | type[httpretty] | type[str] = requests_mock.Mocker
+    y: Union[type[requests_mock.Mocker], type[httpretty], type[str]] = requests_mock.Mocker
+
+
+def func():
+    from typing import Union as U
+
+    # PYI055
+    x: Union[type[requests_mock.Mocker], type[httpretty], type[str]] = requests_mock.Mocker

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

@@ -21,4 +21,5 @@ item: type[requests_mock.Mocker] | type[httpretty] = requests_mock.Mocker
 
 def func():
     # PYI055
-    item: type[requests_mock.Mocker] | type[httpretty] = requests_mock.Mocker
+    item: type[requests_mock.Mocker] | type[httpretty] | type[str] = requests_mock.Mocker
+    item2: Union[type[requests_mock.Mocker], type[httpretty], type[str]] = requests_mock.Mocker

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

@@ -31,6 +31,15 @@ if isinstance(a, bool) or isinstance(b, str):
 if isinstance(a, int) or isinstance(a.b, float):
     pass
 
+# OK
+if isinstance(a, int) or unrelated_condition or isinstance(a, float):
+    pass
+
+if x or isinstance(a, int) or isinstance(a, float):
+    pass
+
+if x or y or isinstance(a, int) or isinstance(a, float) or z:
+    pass
 
 def f():
     # OK

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

@@ -185,3 +185,24 @@ async def f():
         if check(x):
             return True
     return False
+
+async def f():
+    # SIM110
+    for x in await iterable:
+        if check(x):
+            return True
+    return False
+
+def f():
+    # OK (can't turn this into any() because the yield would end up inside a genexp)
+    for x in iterable:
+        if (yield check(x)):
+            return True
+    return False
+
+def f():
+    # OK (same)
+    for x in iterable:
+        if (yield from check(x)):
+            return True
+    return False

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

@@ -42,3 +42,7 @@ with contextlib.ExitStack():
 with contextlib.ExitStack() as exit_stack:
     exit_stack_ = exit_stack
     f = exit_stack_.enter_context(open("filename"))
+
+# OK (quick one-liner to clear file contents)
+open("filename", "w").close()
+pathlib.Path("filename").open("w").close()

crates/ruff_linter/resources/test/fixtures/flake8_use_pathlib/full_name.py

@@ -33,6 +33,8 @@ with open(p) as fp:
     fp.read()
 open(p).close()
 os.getcwdb(p)
+os.path.join(p, *q)
+os.sep.join(p, *q)
 
 # https://github.com/astral-sh/ruff/issues/7620
 def opener(path, flags):

crates/ruff_linter/resources/test/fixtures/pycodestyle/E25.py

@@ -54,3 +54,8 @@ f"{a=}"
 f"{a:=1}"
 f"{foo(a=1)}"
 f"normal {f"{a=}"} normal"
+
+# Okay as the `=` is used inside a f-string...
+print(f"{foo = }")
+# ...but then it creates false negatives for now
+print(f"{foo(a = 1)}")

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

@@ -0,0 +1,19 @@
+"""Test bindings created within annotations."""
+
+from typing import Annotated
+
+foo = [1, 2, 3, 4, 5]
+
+
+class Bar:
+    # OK: Allow list comprehensions in annotations (i.e., treat `qux` as a valid
+    # load in the scope of the annotation).
+    baz: Annotated[
+        str,
+        [qux for qux in foo],
+    ]
+
+
+# OK: Allow named expressions in annotations.
+x: (y := 1)
+print(y)

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

@@ -0,0 +1,21 @@
+"""Test bindings created within annotations under `__future__` annotations."""
+
+from __future__ import annotations
+
+from typing import Annotated
+
+foo = [1, 2, 3, 4, 5]
+
+
+class Bar:
+    # OK: Allow list comprehensions in annotations (i.e., treat `qux` as a valid
+    # load in the scope of the annotation).
+    baz: Annotated[
+        str,
+        [qux for qux in foo],
+    ]
+
+
+# Error: `y` is not defined.
+x: (y := 1)
+print(y)

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

@@ -0,0 +1,73 @@
+# OK
+
+1<2 and 'b' and 'c'
+
+1<2 or 'a' and 'b'
+
+1<2 and 'a'
+
+1<2 or 'a'
+
+2>1
+
+1<2 and 'a' or 'b' and 'c'
+
+1<2 and 'a' or 'b' or 'c'
+
+1<2 and 'a' or 'b' or 'c' or (lambda x: x+1)
+
+1<2 and 'a' or 'b' or (lambda x: x+1) or 'c'
+
+default = 'default'
+if (not isinstance(default, bool) and isinstance(default, int)) \
+        or (isinstance(default, str) and default):
+    pass
+
+docid, token = None, None
+(docid is None and token is None) or (docid is not None and token is not None)
+
+vendor, os_version = 'darwin', '14'
+vendor == "debian" and os_version in ["12"] or vendor == "ubuntu" and os_version in []
+
+# Don't emit if the parent is an `if` statement.
+if (task_id in task_dict and task_dict[task_id] is not task) \
+        or task_id in used_group_ids:
+    pass
+
+no_target, is_x64, target = True, False, 'target'
+if (no_target and not is_x64) or target == 'ARM_APPL_RUST_TARGET':
+    pass
+
+# Don't emit if the parent is a `bool_op` expression.
+isinstance(val, str) and ((len(val) == 7 and val[0] == "#") or val in enums.NamedColor)
+
+# Errors
+
+1<2 and 'a' or 'b'
+
+(lambda x: x+1) and 'a' or 'b'
+
+'a' and (lambda x: x+1) or 'orange'
+
+val = '#0000FF'
+(len(val) == 7 and val[0] == "#") or val in {'green'}
+
+marker = 'marker'
+isinstance(marker, dict) and 'field' in marker or marker in {}
+
+def has_oranges(oranges, apples=None) -> bool:
+    return apples and False or oranges
+
+[x for x in l if a and b or c]
+
+{x: y for x in l if a and b or c}
+
+{x for x in l if a and b or c}
+
+new_list = [
+    x
+    for sublist in all_lists
+    if a and b or c
+    for x in sublist
+    if (isinstance(operator, list) and x in operator) or x != operator
+]

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

@@ -1,5 +1,8 @@
 # Errors
 
+for item in {1}:
+    print(f"I can count to {item}!")
+
 for item in {"apples", "lemons", "water"}:  # flags in-line set literals
     print(f"I like {item}.")
 

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

@@ -202,3 +202,8 @@ aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
 "{}".format(
     1  # comment
 )
+
+
+# The fixed string will exceed the line length, but it's still smaller than the
+# existing line length, so it's fine.
+"<Customer: {}, {}, {}, {}, {}>".format(self.internal_ids, self.external_ids, self.properties, self.tags, self.others)

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

@@ -0,0 +1,9 @@
+from django.utils.translation import gettext
+
+long = 'long'
+split_to = 'split_to'
+gettext(
+    'some super {} and complicated string so that the error code '
+    'E501 Triggers when this is not {} multi-line'.format(
+        long, split_to)
+)

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

@@ -196,3 +196,9 @@ if sys.version_info < (3,10000000):
 
 if sys.version_info <= (3,10000000):
     print("py3")
+
+if sys.version_info > (3,12):
+    print("py3")
+
+if sys.version_info >= (3,12):
+    print("py3")

crates/ruff_linter/resources/test/fixtures/pyupgrade/UP040.pyi

@@ -0,0 +1,7 @@
+import typing
+from typing import TypeAlias
+
+# UP040
+# Fixes in type stub files should be safe to apply unlike in regular code where runtime behavior could change
+x: typing.TypeAlias = int
+x: TypeAlias = int

crates/ruff_linter/resources/test/fixtures/refurb/FURB140.py

@@ -24,6 +24,12 @@ from itertools import starmap as sm
 # FURB140
 {print(x, y) for x, y in zipped()}
 
+# FURB140 (check it still flags starred arguments).
+# See https://github.com/astral-sh/ruff/issues/7636
+[foo(*t) for t in [(85, 60), (100, 80)]]
+(foo(*t) for t in [(85, 60), (100, 80)])
+{foo(*t) for t in [(85, 60), (100, 80)]}
+
 # Non-errors.
 
 [print(x, int) for x, _ in zipped()]
@@ -41,3 +47,9 @@ from itertools import starmap as sm
 [print() for x, y in zipped()]
 
 [print(x, end=y) for x, y in zipped()]
+
+[print(*x, y) for x, y in zipped()]
+
+[print(x, *y) for x, y in zipped()]
+
+[print(*x, *y) for x, y in zipped()]

crates/ruff_linter/resources/test/fixtures/refurb/FURB148.py

@@ -1,5 +1,15 @@
 books = ["Dune", "Foundation", "Neuromancer"]
 
+books_and_authors = {
+    "Dune": "Frank Herbert",
+    "Foundation": "Isaac Asimov",
+    "Neuromancer": "William Gibson",
+}
+
+books_set = {"Dune", "Foundation", "Neuromancer"}
+
+books_tuple = ("Dune", "Foundation", "Neuromancer")
+
 # Errors
 for index, _ in enumerate(books):
     print(index)
@@ -55,6 +65,24 @@ for(index, _)in enumerate(books):
 for(index), _ in enumerate(books):
     print(index)
 
+for index, _ in enumerate(books_and_authors):
+    print(index)
+
+for _, book in enumerate(books_and_authors):
+    print(book)
+
+for index, _ in enumerate(books_set):
+    print(index)
+
+for _, book in enumerate(books_set):
+    print(book)
+
+for index, _ in enumerate(books_tuple):
+    print(index)
+
+for _, book in enumerate(books_tuple):
+    print(book)
+
 # OK
 for index, book in enumerate(books):
     print(index, book)
@@ -64,3 +92,9 @@ for index in range(len(books)):
 
 for book in books:
     print(book)
+
+# Generators don't support the len() function.
+# https://github.com/astral-sh/ruff/issues/7656
+a = (b for b in range(1, 100))
+for i, _ in enumerate(a):
+    print(i)

crates/ruff_linter/resources/test/fixtures/refurb/FURB171.py

@@ -0,0 +1,45 @@
+# Errors.
+
+if 1 in (1,):
+    print("Single-element tuple")
+
+if 1 in [1]:
+    print("Single-element list")
+
+if 1 in {1}:
+    print("Single-element set")
+
+if "a" in "a":
+    print("Single-element string")
+
+if 1 not in (1,):
+    print("Check `not in` membership test")
+
+if not 1 in (1,):
+    print("Check the negated membership test")
+
+# Non-errors.
+
+if 1 in (1, 2):
+    pass
+
+if 1 in [1, 2]:
+    pass
+
+if 1 in {1, 2}:
+    pass
+
+if "a" in "ab":
+    pass
+
+if 1 == (1,):
+    pass
+
+if 1 > [1]:
+    pass
+
+if 1 is {1}:
+    pass
+
+if "a" == "a":
+    pass

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

@@ -37,3 +37,14 @@ class D(BaseModel):
     without_annotation = []
     class_variable: ClassVar[list[int]] = []
     final_variable: Final[list[int]] = []
+
+
+from msgspec import Struct
+
+
+class E(Struct):
+    mutable_default: list[int] = []
+    immutable_annotation: Sequence[int] = []
+    without_annotation = []
+    class_variable: ClassVar[list[int]] = []
+    final_variable: Final[list[int]] = []

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

@@ -38,6 +38,13 @@ y = range(10)
 list(range(10))[0]
 list(x.y)[0]
 list(x["y"])[0]
+[*range(10)][0]
+[*x["y"]][0]
+[*x.y][0]
+[* x.y][0]
+[
+    *x.y
+][0]
 
 # RUF015 (multi-line)
 revision_heads_map_ast = [
@@ -45,3 +52,12 @@ revision_heads_map_ast = [
     for a in revision_heads_map_ast_obj.body
     if isinstance(a, ast.Assign) and a.targets[0].id == "REVISION_HEADS_MAP"
 ][0]
+
+# RUF015 (zip)
+list(zip(x, y))[0]
+[*zip(x, y)][0]
+
+
+def test():
+    zip = list  # Overwrite the builtin zip
+    list(zip(x, y))[0]

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

@@ -0,0 +1,7 @@
+# RUF018
+assert (x := 0) == 0
+assert x, (y := "error")
+
+# OK
+if z := 0:
+    pass

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

@@ -0,0 +1,20 @@
+d = {}
+# RUF019
+if "k" in d and d["k"]:
+    pass
+
+k = "k"
+if k in d and d[k]:
+    pass
+
+if (k) in d and d[k]:
+    pass
+
+if k in d and d[(k)]:
+    pass
+
+# OK
+v = "k" in d and d["k"]
+
+if f() in d and d[f()]:
+    pass

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

@@ -32,15 +32,10 @@ pub(crate) fn bindings(checker: &mut Checker) {
                     },
                     binding.range(),
                 );
-                if checker.patch(Rule::UnusedVariable) {
-                    diagnostic.try_set_fix(|| {
-                        pyflakes::fixes::remove_exception_handler_assignment(
-                            binding,
-                            checker.locator,
-                        )
-                        .map(Fix::automatic)
-                    });
-                }
+                diagnostic.try_set_fix(|| {
+                    pyflakes::fixes::remove_exception_handler_assignment(binding, checker.locator)
+                        .map(Fix::safe_edit)
+                });
                 checker.diagnostics.push(diagnostic);
             }
         }

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

@@ -414,13 +414,7 @@ pub(crate) fn expression(expr: &Expr, checker: &mut Checker) {
                                         pyupgrade::rules::format_literals(checker, call, &summary);
                                     }
                                     if checker.enabled(Rule::FString) {
-                                        pyupgrade::rules::f_strings(
-                                            checker,
-                                            call,
-                                            &summary,
-                                            value,
-                                            checker.settings.line_length,
-                                        );
+                                        pyupgrade::rules::f_strings(checker, call, &summary, value);
                                     }
                                 }
                             }
@@ -680,9 +674,7 @@ pub(crate) fn expression(expr: &Expr, checker: &mut Checker) {
                 );
             }
             if checker.enabled(Rule::UnnecessarySubscriptReversal) {
-                flake8_comprehensions::rules::unnecessary_subscript_reversal(
-                    checker, expr, func, args,
-                );
+                flake8_comprehensions::rules::unnecessary_subscript_reversal(checker, call);
             }
             if checker.enabled(Rule::UnnecessaryMap) {
                 flake8_comprehensions::rules::unnecessary_map(
@@ -1226,6 +1218,9 @@ pub(crate) fn expression(expr: &Expr, checker: &mut Checker) {
                     comparators,
                 );
             }
+            if checker.enabled(Rule::SingleItemMembershipTest) {
+                refurb::rules::single_item_membership_test(checker, expr, left, ops, comparators);
+            }
         }
         Expr::Constant(ast::ExprConstant {
             value: Constant::Int(_) | Constant::Float(_) | Constant::Complex { .. },
@@ -1417,6 +1412,17 @@ pub(crate) fn expression(expr: &Expr, checker: &mut Checker) {
             if checker.enabled(Rule::RepeatedEqualityComparison) {
                 pylint::rules::repeated_equality_comparison(checker, bool_op);
             }
+            if checker.enabled(Rule::AndOrTernary) {
+                pylint::rules::and_or_ternary(checker, bool_op);
+            }
+            if checker.enabled(Rule::UnnecessaryKeyCheck) {
+                ruff::rules::unnecessary_key_check(checker, expr);
+            }
+        }
+        Expr::NamedExpr(..) => {
+            if checker.enabled(Rule::AssignmentInAssert) {
+                ruff::rules::assignment_in_assert(checker, expr);
+            }
         }
         _ => {}
     };

crates/ruff_linter/src/checkers/ast/mod.rs

@@ -143,11 +143,6 @@ impl<'a> Checker<'a> {
 }
 
 impl<'a> Checker<'a> {
-    /// Return `true` if a patch should be generated for a given [`Rule`].
-    pub(crate) fn patch(&self, code: Rule) -> bool {
-        self.settings.rules.should_fix(code)
-    }
-
     /// Return `true` if a [`Rule`] is disabled by a `noqa` directive.
     pub(crate) fn rule_is_ignored(&self, code: Rule, offset: TextSize) -> bool {
         // TODO(charlie): `noqa` directives are mostly enforced in `check_lines.rs`.
@@ -1168,13 +1163,14 @@ where
                                 range: _,
                             }) = slice.as_ref()
                             {
-                                if let Some(expr) = elts.first() {
+                                let mut iter = elts.iter();
+                                if let Some(expr) = iter.next() {
                                     self.visit_expr(expr);
-                                    for expr in elts.iter().skip(1) {
-                                        self.visit_non_type_definition(expr);
-                                    }
-                                    self.visit_expr_context(ctx);
                                 }
+                                for expr in iter {
+                                    self.visit_non_type_definition(expr);
+                                }
+                                self.visit_expr_context(ctx);
                             } else {
                                 debug!("Found non-Expr::Tuple argument to PEP 593 Annotation.");
                             }
@@ -1366,7 +1362,7 @@ where
     fn visit_match_case(&mut self, match_case: &'b MatchCase) {
         self.visit_pattern(&match_case.pattern);
         if let Some(expr) = &match_case.guard {
-            self.visit_expr(expr);
+            self.visit_boolean_test(expr);
         }
 
         self.semantic.push_branch();
@@ -1618,10 +1614,12 @@ impl<'a> Checker<'a> {
     fn handle_node_store(&mut self, id: &'a str, expr: &Expr) {
         let parent = self.semantic.current_statement();
 
+        // Match the left-hand side of an annotated assignment, like `x` in `x: int`.
         if matches!(
             parent,
             Stmt::AnnAssign(ast::StmtAnnAssign { value: None, .. })
-        ) {
+        ) && !self.semantic.in_annotation()
+        {
             self.add_binding(
                 id,
                 expr.range(),

crates/ruff_linter/src/checkers/logical_lines.rs

@@ -5,7 +5,7 @@ use ruff_python_parser::TokenKind;
 use ruff_source_file::Locator;
 use ruff_text_size::{Ranged, TextRange};
 
-use crate::registry::{AsRule, Rule};
+use crate::registry::AsRule;
 use crate::rules::pycodestyle::rules::logical_lines::{
     extraneous_whitespace, indentation, missing_whitespace, missing_whitespace_after_keyword,
     missing_whitespace_around_operator, space_after_comma, space_around_operator,
@@ -38,17 +38,6 @@ pub(crate) fn check_logical_lines(
 ) -> Vec<Diagnostic> {
     let mut context = LogicalLinesContext::new(settings);
 
-    let should_fix_missing_whitespace = settings.rules.should_fix(Rule::MissingWhitespace);
-    let should_fix_whitespace_before_parameters =
-        settings.rules.should_fix(Rule::WhitespaceBeforeParameters);
-    let should_fix_whitespace_after_open_bracket =
-        settings.rules.should_fix(Rule::WhitespaceAfterOpenBracket);
-    let should_fix_whitespace_before_close_bracket = settings
-        .rules
-        .should_fix(Rule::WhitespaceBeforeCloseBracket);
-    let should_fix_whitespace_before_punctuation =
-        settings.rules.should_fix(Rule::WhitespaceBeforePunctuation);
-
     let mut prev_line = None;
     let mut prev_indent_level = None;
     let indent_char = stylist.indentation().as_char();
@@ -58,7 +47,7 @@ pub(crate) fn check_logical_lines(
             space_around_operator(&line, &mut context);
             whitespace_around_named_parameter_equals(&line, &mut context);
             missing_whitespace_around_operator(&line, &mut context);
-            missing_whitespace(&line, should_fix_missing_whitespace, &mut context);
+            missing_whitespace(&line, &mut context);
         }
         if line.flags().contains(TokenFlags::PUNCTUATION) {
             space_after_comma(&line, &mut context);
@@ -68,13 +57,7 @@ pub(crate) fn check_logical_lines(
             .flags()
             .intersects(TokenFlags::OPERATOR | TokenFlags::BRACKET | TokenFlags::PUNCTUATION)
         {
-            extraneous_whitespace(
-                &line,
-                &mut context,
-                should_fix_whitespace_after_open_bracket,
-                should_fix_whitespace_before_close_bracket,
-                should_fix_whitespace_before_punctuation,
-            );
+            extraneous_whitespace(&line, &mut context);
         }
 
         if line.flags().contains(TokenFlags::KEYWORD) {
@@ -87,11 +70,7 @@ pub(crate) fn check_logical_lines(
         }
 
         if line.flags().contains(TokenFlags::BRACKET) {
-            whitespace_before_parameters(
-                &line,
-                should_fix_whitespace_before_parameters,
-                &mut context,
-            );
+            whitespace_before_parameters(&line, &mut context);
         }
 
         // Extract the indentation level.

crates/ruff_linter/src/checkers/noqa.rs

@@ -109,10 +109,8 @@ pub(crate) fn check_noqa(
                     if line.matches.is_empty() {
                         let mut diagnostic =
                             Diagnostic::new(UnusedNOQA { codes: None }, directive.range());
-                        if settings.rules.should_fix(diagnostic.kind.rule()) {
-                            diagnostic
-                                .set_fix(Fix::suggested(delete_noqa(directive.range(), locator)));
-                        }
+                        diagnostic.set_fix(Fix::safe_edit(delete_noqa(directive.range(), locator)));
+
                         diagnostics.push(diagnostic);
                     }
                 }
@@ -173,18 +171,14 @@ pub(crate) fn check_noqa(
                             },
                             directive.range(),
                         );
-                        if settings.rules.should_fix(diagnostic.kind.rule()) {
-                            if valid_codes.is_empty() {
-                                diagnostic.set_fix(Fix::suggested(delete_noqa(
-                                    directive.range(),
-                                    locator,
-                                )));
-                            } else {
-                                diagnostic.set_fix(Fix::suggested(Edit::range_replacement(
-                                    format!("# noqa: {}", valid_codes.join(", ")),
-                                    directive.range(),
-                                )));
-                            }
+                        if valid_codes.is_empty() {
+                            diagnostic
+                                .set_fix(Fix::safe_edit(delete_noqa(directive.range(), locator)));
+                        } else {
+                            diagnostic.set_fix(Fix::safe_edit(Edit::range_replacement(
+                                format!("# noqa: {}", valid_codes.join(", ")),
+                                directive.range(),
+                            )));
                         }
                         diagnostics.push(diagnostic);
                     }

crates/ruff_linter/src/checkers/physical_lines.rs

@@ -71,11 +71,7 @@ pub(crate) fn check_physical_lines(
     }
 
     if enforce_no_newline_at_end_of_file {
-        if let Some(diagnostic) = no_newline_at_end_of_file(
-            locator,
-            stylist,
-            settings.rules.should_fix(Rule::MissingNewlineAtEndOfFile),
-        ) {
+        if let Some(diagnostic) = no_newline_at_end_of_file(locator, stylist) {
             diagnostics.push(diagnostic);
         }
     }

crates/ruff_linter/src/checkers/tokens.rs

@@ -72,7 +72,7 @@ pub(crate) fn check_tokens(
     }
 
     if settings.rules.enabled(Rule::UTF8EncodingDeclaration) {
-        pyupgrade::rules::unnecessary_coding_comment(&mut diagnostics, locator, indexer, settings);
+        pyupgrade::rules::unnecessary_coding_comment(&mut diagnostics, locator, indexer);
     }
 
     if settings.rules.enabled(Rule::InvalidEscapeSequence) {
@@ -83,7 +83,6 @@ pub(crate) fn check_tokens(
                 indexer,
                 tok,
                 *range,
-                settings.rules.should_fix(Rule::InvalidEscapeSequence),
             );
         }
     }
@@ -109,13 +108,7 @@ pub(crate) fn check_tokens(
         Rule::MultipleStatementsOnOneLineSemicolon,
         Rule::UselessSemicolon,
     ]) {
-        pycodestyle::rules::compound_statements(
-            &mut diagnostics,
-            tokens,
-            locator,
-            indexer,
-            settings,
-        );
+        pycodestyle::rules::compound_statements(&mut diagnostics, tokens, locator, indexer);
     }
 
     if settings.rules.enabled(Rule::AvoidableEscapedQuote) && settings.flake8_quotes.avoid_escape {
@@ -137,7 +130,7 @@ pub(crate) fn check_tokens(
         flake8_implicit_str_concat::rules::implicit(
             &mut diagnostics,
             tokens,
-            &settings.flake8_implicit_str_concat,
+            settings,
             locator,
             indexer,
         );
@@ -148,11 +141,11 @@ pub(crate) fn check_tokens(
         Rule::TrailingCommaOnBareTuple,
         Rule::ProhibitedTrailingComma,
     ]) {
-        flake8_commas::rules::trailing_commas(&mut diagnostics, tokens, locator, settings);
+        flake8_commas::rules::trailing_commas(&mut diagnostics, tokens, locator);
     }
 
     if settings.rules.enabled(Rule::ExtraneousParentheses) {
-        pyupgrade::rules::extraneous_parentheses(&mut diagnostics, tokens, locator, settings);
+        pyupgrade::rules::extraneous_parentheses(&mut diagnostics, tokens, locator);
     }
 
     if is_stub && settings.rules.enabled(Rule::TypeCommentInStub) {
@@ -166,7 +159,7 @@ pub(crate) fn check_tokens(
         Rule::ShebangNotFirstLine,
         Rule::ShebangMissingPython,
     ]) {
-        flake8_executable::rules::from_tokens(tokens, path, locator, settings, &mut diagnostics);
+        flake8_executable::rules::from_tokens(tokens, path, locator, &mut diagnostics);
     }
 
     if settings.rules.any_enabled(&[
@@ -191,7 +184,7 @@ pub(crate) fn check_tokens(
                 TodoComment::from_comment(comment, *comment_range, i)
             })
             .collect();
-        flake8_todos::rules::todos(&mut diagnostics, &todo_comments, locator, indexer, settings);
+        flake8_todos::rules::todos(&mut diagnostics, &todo_comments, locator, indexer);
         flake8_fixme::rules::todos(&mut diagnostics, &todo_comments);
     }
 

crates/ruff_linter/src/codes.rs

@@ -249,6 +249,7 @@ pub fn code_to_rule(linter: Linter, code: &str) -> Option<(RuleGroup, Rule)> {
         (Pylint, "R1701") => (RuleGroup::Unspecified, rules::pylint::rules::RepeatedIsinstanceCalls),
         (Pylint, "R1711") => (RuleGroup::Unspecified, rules::pylint::rules::UselessReturn),
         (Pylint, "R1714") => (RuleGroup::Unspecified, rules::pylint::rules::RepeatedEqualityComparison),
+        (Pylint, "R1706") => (RuleGroup::Preview, rules::pylint::rules::AndOrTernary),
         (Pylint, "R1722") => (RuleGroup::Unspecified, rules::pylint::rules::SysExitAlias),
         (Pylint, "R2004") => (RuleGroup::Unspecified, rules::pylint::rules::MagicValueComparison),
         (Pylint, "R5501") => (RuleGroup::Unspecified, rules::pylint::rules::CollapsibleElseIf),
@@ -865,6 +866,8 @@ pub fn code_to_rule(linter: Linter, code: &str) -> Option<(RuleGroup, Rule)> {
         (Ruff, "016") => (RuleGroup::Unspecified, rules::ruff::rules::InvalidIndexType),
         #[allow(deprecated)]
         (Ruff, "017") => (RuleGroup::Nursery, rules::ruff::rules::QuadraticListSummation),
+        (Ruff, "018") => (RuleGroup::Preview, rules::ruff::rules::AssignmentInAssert),
+        (Ruff, "019") => (RuleGroup::Preview, rules::ruff::rules::UnnecessaryKeyCheck),
         (Ruff, "100") => (RuleGroup::Unspecified, rules::ruff::rules::UnusedNOQA),
         (Ruff, "200") => (RuleGroup::Unspecified, rules::ruff::rules::InvalidPyprojectToml),
 
@@ -923,6 +926,7 @@ pub fn code_to_rule(linter: Linter, code: &str) -> Option<(RuleGroup, Rule)> {
         (Refurb, "140") => (RuleGroup::Preview, rules::refurb::rules::ReimplementedStarmap),
         (Refurb, "145") => (RuleGroup::Preview, rules::refurb::rules::SliceCopy),
         (Refurb, "148") => (RuleGroup::Preview, rules::refurb::rules::UnnecessaryEnumerate),
+        (Refurb, "171") => (RuleGroup::Preview, rules::refurb::rules::SingleItemMembershipTest),
         (Refurb, "177") => (RuleGroup::Preview, rules::refurb::rules::ImplicitCwd),
 
         // flake8-logging

crates/ruff_linter/src/fix/edits.rs

@@ -3,16 +3,18 @@
 use anyhow::{Context, Result};
 
 use ruff_diagnostics::Edit;
+use ruff_python_ast::node::AnyNodeRef;
 use ruff_python_ast::{self as ast, Arguments, ExceptHandler, Stmt};
 use ruff_python_codegen::Stylist;
 use ruff_python_index::Indexer;
 use ruff_python_trivia::{
     has_leading_content, is_python_whitespace, PythonWhitespace, SimpleTokenKind, SimpleTokenizer,
 };
-use ruff_source_file::{Locator, NewlineWithTrailingNewline};
+use ruff_source_file::{Locator, NewlineWithTrailingNewline, UniversalNewlines};
 use ruff_text_size::{Ranged, TextLen, TextRange, TextSize};
 
 use crate::fix::codemods;
+use crate::line_width::{LineLength, LineWidthBuilder, TabSize};
 
 /// Return the `Fix` to use when deleting a `Stmt`.
 ///
@@ -285,6 +287,75 @@ pub(crate) fn pad(content: String, range: TextRange, locator: &Locator) -> Strin
     )
 }
 
+/// Returns `true` if the fix fits within the maximum configured line length.
+pub(crate) fn fits(
+    fix: &str,
+    node: AnyNodeRef,
+    locator: &Locator,
+    line_length: LineLength,
+    tab_size: TabSize,
+) -> bool {
+    all_lines_fit(fix, node, locator, line_length.value() as usize, tab_size)
+}
+
+/// Returns `true` if the fix fits within the maximum configured line length, or produces lines that
+/// are shorter than the maximum length of the existing AST node.
+pub(crate) fn fits_or_shrinks(
+    fix: &str,
+    node: AnyNodeRef,
+    locator: &Locator,
+    line_length: LineLength,
+    tab_size: TabSize,
+) -> bool {
+    // Use the larger of the line length limit, or the longest line in the existing AST node.
+    let line_length = std::iter::once(line_length.value() as usize)
+        .chain(
+            locator
+                .slice(locator.lines_range(node.range()))
+                .universal_newlines()
+                .map(|line| LineWidthBuilder::new(tab_size).add_str(&line).get()),
+        )
+        .max()
+        .unwrap_or(line_length.value() as usize);
+
+    all_lines_fit(fix, node, locator, line_length, tab_size)
+}
+
+/// Returns `true` if all lines in the fix are shorter than the given line length.
+fn all_lines_fit(
+    fix: &str,
+    node: AnyNodeRef,
+    locator: &Locator,
+    line_length: usize,
+    tab_size: TabSize,
+) -> bool {
+    let prefix = locator.slice(TextRange::new(
+        locator.line_start(node.start()),
+        node.start(),
+    ));
+
+    // Ensure that all lines are shorter than the line length limit.
+    fix.universal_newlines().enumerate().all(|(idx, line)| {
+        // If `template` is a multiline string, `col_offset` should only be applied to the first
+        // line:
+        // ```
+        // a = """{}        -> offset = col_offset (= 4)
+        // {}               -> offset = 0
+        // """.format(0, 1) -> offset = 0
+        // ```
+        let measured_length = if idx == 0 {
+            LineWidthBuilder::new(tab_size)
+                .add_str(prefix)
+                .add_str(&line)
+                .get()
+        } else {
+            LineWidthBuilder::new(tab_size).add_str(&line).get()
+        };
+
+        measured_length <= line_length
+    })
+}
+
 #[cfg(test)]
 mod tests {
     use anyhow::Result;

crates/ruff_linter/src/fix/mod.rs

@@ -9,6 +9,7 @@ use ruff_source_file::Locator;
 
 use crate::linter::FixTable;
 use crate::registry::{AsRule, Rule};
+use crate::settings::types::UnsafeFixes;
 
 pub(crate) mod codemods;
 pub(crate) mod edits;
@@ -23,11 +24,22 @@ pub(crate) struct FixResult {
     pub(crate) source_map: SourceMap,
 }
 
-/// Auto-fix errors in a file, and write the fixed source code to disk.
-pub(crate) fn fix_file(diagnostics: &[Diagnostic], locator: &Locator) -> Option<FixResult> {
+/// Fix errors in a file, and write the fixed source code to disk.
+pub(crate) fn fix_file(
+    diagnostics: &[Diagnostic],
+    locator: &Locator,
+    unsafe_fixes: UnsafeFixes,
+) -> Option<FixResult> {
+    let required_applicability = unsafe_fixes.required_applicability();
+
     let mut with_fixes = diagnostics
         .iter()
-        .filter(|diag| diag.fix.is_some())
+        .filter(|diagnostic| {
+            diagnostic
+                .fix
+                .as_ref()
+                .map_or(false, |fix| fix.applies(required_applicability))
+        })
         .peekable();
 
     if with_fixes.peek().is_none() {
@@ -151,7 +163,7 @@ mod tests {
                 // The choice of rule here is arbitrary.
                 kind: MissingNewlineAtEndOfFile.into(),
                 range: edit.range(),
-                fix: Some(Fix::unspecified(edit)),
+                fix: Some(Fix::safe_edit(edit)),
                 parent: None,
             })
             .collect()

crates/ruff_linter/src/line_width.rs

@@ -1,19 +1,23 @@
-use ruff_cache::{CacheKey, CacheKeyHasher};
-use serde::{Deserialize, Serialize};
 use std::error::Error;
 use std::hash::Hasher;
 use std::num::{NonZeroU16, NonZeroU8, ParseIntError};
 use std::str::FromStr;
+
+use serde::{Deserialize, Serialize};
 use unicode_width::UnicodeWidthChar;
 
+use ruff_cache::{CacheKey, CacheKeyHasher};
 use ruff_macros::CacheKey;
+use ruff_text_size::TextSize;
 
 /// The length of a line of text that is considered too long.
 ///
 /// The allowed range of values is 1..=320
 #[derive(Clone, Copy, Debug, Eq, PartialEq, serde::Serialize, serde::Deserialize)]
 #[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
-pub struct LineLength(NonZeroU16);
+pub struct LineLength(
+    #[cfg_attr(feature = "schemars", schemars(range(min = 1, max = 320)))] NonZeroU16,
+);
 
 impl LineLength {
     /// Maximum allowed value for a valid [`LineLength`]
@@ -23,6 +27,10 @@ impl LineLength {
     pub fn value(&self) -> u16 {
         self.0.get()
     }
+
+    pub fn text_len(&self) -> TextSize {
+        TextSize::from(u32::from(self.value()))
+    }
 }
 
 impl Default for LineLength {

crates/ruff_linter/src/linter.rs

@@ -8,7 +8,7 @@ use itertools::Itertools;
 use log::error;
 use rustc_hash::FxHashMap;
 
-use ruff_diagnostics::Diagnostic;
+use ruff_diagnostics::{Applicability, Diagnostic};
 use ruff_python_ast::imports::ImportMap;
 use ruff_python_ast::PySourceType;
 use ruff_python_codegen::Stylist;
@@ -32,6 +32,7 @@ use crate::message::Message;
 use crate::noqa::add_noqa;
 use crate::registry::{AsRule, Rule};
 use crate::rules::pycodestyle;
+use crate::settings::types::UnsafeFixes;
 use crate::settings::{flags, LinterSettings};
 use crate::source_kind::SourceKind;
 use crate::{directives, fs};
@@ -259,6 +260,36 @@ pub fn check_path(
         }
     }
 
+    // Remove fixes for any rules marked as unfixable.
+    for diagnostic in &mut diagnostics {
+        if !settings.rules.should_fix(diagnostic.kind.rule()) {
+            diagnostic.fix = None;
+        }
+    }
+
+    // Update fix applicability to account for overrides
+    if !settings.extend_safe_fixes.is_empty() || !settings.extend_unsafe_fixes.is_empty() {
+        for diagnostic in &mut diagnostics {
+            if let Some(fix) = diagnostic.fix.take() {
+                // Enforce demotions over promotions so if someone puts a rule in both we are conservative
+                if fix.applicability().is_safe()
+                    && settings
+                        .extend_unsafe_fixes
+                        .contains(diagnostic.kind.rule())
+                {
+                    diagnostic.set_fix(fix.with_applicability(Applicability::Unsafe));
+                } else if fix.applicability().is_unsafe()
+                    && settings.extend_safe_fixes.contains(diagnostic.kind.rule())
+                {
+                    diagnostic.set_fix(fix.with_applicability(Applicability::Safe));
+                } else {
+                    // Retain the existing fix (will be dropped from `.take()` otherwise)
+                    diagnostic.set_fix(fix);
+                }
+            }
+        }
+    }
+
     LinterResult::new((diagnostics, imports), error)
 }
 
@@ -415,10 +446,12 @@ fn diagnostics_to_messages(
 
 /// Generate `Diagnostic`s from source code content, iteratively fixing
 /// until stable.
+#[allow(clippy::too_many_arguments)]
 pub fn lint_fix<'a>(
     path: &Path,
     package: Option<&Path>,
     noqa: flags::Noqa,
+    unsafe_fixes: UnsafeFixes,
     settings: &LinterSettings,
     source_kind: &'a SourceKind,
     source_type: PySourceType,
@@ -494,7 +527,7 @@ pub fn lint_fix<'a>(
             code: fixed_contents,
             fixes: applied,
             source_map,
-        }) = fix_file(&result.data.0, &locator)
+        }) = fix_file(&result.data.0, &locator, unsafe_fixes)
         {
             if iterations < MAX_ITERATIONS {
                 // Count the number of fixed errors.

crates/ruff_linter/src/logging.rs

@@ -177,18 +177,15 @@ impl Display for DisplayParseError<'_> {
                     f,
                     "cell {cell}{colon}",
                     cell = jupyter_index
-                        .cell(source_location.row.get())
-                        .unwrap_or_default(),
+                        .cell(source_location.row)
+                        .unwrap_or(OneIndexed::MIN),
                     colon = ":".cyan(),
                 )?;
 
                 SourceLocation {
-                    row: OneIndexed::new(
-                        jupyter_index
-                            .cell_row(source_location.row.get())
-                            .unwrap_or(1) as usize,
-                    )
-                    .unwrap(),
+                    row: jupyter_index
+                        .cell_row(source_location.row)
+                        .unwrap_or(OneIndexed::MIN),
                     column: source_location.column,
                 }
             } else {

crates/ruff_linter/src/message/diff.rs

@@ -35,6 +35,7 @@ impl<'a> Diff<'a> {
 
 impl Display for Diff<'_> {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        // TODO(dhruvmanila): Add support for Notebook cells once it's user-facing
         let mut output = String::with_capacity(self.source_code.source_text().len());
         let mut last_end = TextSize::default();
 
@@ -52,10 +53,10 @@ impl Display for Diff<'_> {
         let diff = TextDiff::from_lines(self.source_code.source_text(), &output);
 
         let message = match self.fix.applicability() {
-            Applicability::Automatic => "Fix",
-            Applicability::Suggested => "Suggested fix",
-            Applicability::Manual => "Possible fix",
-            Applicability::Unspecified => "Suggested fix", /* For backwards compatibility, unspecified fixes are 'suggested' */
+            // TODO(zanieb): Adjust this messaging once it's user-facing
+            Applicability::Safe => "Fix",
+            Applicability::Unsafe => "Suggested fix",
+            Applicability::Display => "Possible fix",
         };
         writeln!(f, "ℹ {}", message.blue())?;
 

crates/ruff_linter/src/message/grouped.rs

@@ -13,11 +13,13 @@ use crate::message::text::{MessageCodeFrame, RuleCodeAndBody};
 use crate::message::{
     group_messages_by_filename, Emitter, EmitterContext, Message, MessageWithLocation,
 };
+use crate::settings::types::UnsafeFixes;
 
 #[derive(Default)]
 pub struct GroupedEmitter {
     show_fix_status: bool,
     show_source: bool,
+    unsafe_fixes: UnsafeFixes,
 }
 
 impl GroupedEmitter {
@@ -32,6 +34,12 @@ impl GroupedEmitter {
         self.show_source = show_source;
         self
     }
+
+    #[must_use]
+    pub fn with_unsafe_fixes(mut self, unsafe_fixes: UnsafeFixes) -> Self {
+        self.unsafe_fixes = unsafe_fixes;
+        self
+    }
 }
 
 impl Emitter for GroupedEmitter {
@@ -68,6 +76,7 @@ impl Emitter for GroupedEmitter {
                         notebook_index: context.notebook_index(message.filename()),
                         message,
                         show_fix_status: self.show_fix_status,
+                        unsafe_fixes: self.unsafe_fixes,
                         show_source: self.show_source,
                         row_length,
                         column_length,
@@ -89,6 +98,7 @@ impl Emitter for GroupedEmitter {
 struct DisplayGroupedMessage<'a> {
     message: MessageWithLocation<'a>,
     show_fix_status: bool,
+    unsafe_fixes: UnsafeFixes,
     show_source: bool,
     row_length: NonZeroUsize,
     column_length: NonZeroUsize,
@@ -115,18 +125,18 @@ impl Display for DisplayGroupedMessage<'_> {
                 f,
                 "cell {cell}{sep}",
                 cell = jupyter_index
-                    .cell(start_location.row.get())
-                    .unwrap_or_default(),
+                    .cell(start_location.row)
+                    .unwrap_or(OneIndexed::MIN),
                 sep = ":".cyan()
             )?;
             (
                 jupyter_index
-                    .cell_row(start_location.row.get())
-                    .unwrap_or(1) as usize,
-                start_location.column.get(),
+                    .cell_row(start_location.row)
+                    .unwrap_or(OneIndexed::MIN),
+                start_location.column,
             )
         } else {
-            (start_location.row.get(), start_location.column.get())
+            (start_location.row, start_location.column)
         };
 
         writeln!(
@@ -138,7 +148,8 @@ impl Display for DisplayGroupedMessage<'_> {
             ),
             code_and_body = RuleCodeAndBody {
                 message,
-                show_fix_status: self.show_fix_status
+                show_fix_status: self.show_fix_status,
+                unsafe_fixes: self.unsafe_fixes
             },
         )?;
 
@@ -196,6 +207,7 @@ mod tests {
 
     use crate::message::tests::{capture_emitter_output, create_messages};
     use crate::message::GroupedEmitter;
+    use crate::settings::types::UnsafeFixes;
 
     #[test]
     fn default() {
@@ -222,4 +234,15 @@ mod tests {
 
         assert_snapshot!(content);
     }
+
+    #[test]
+    fn fix_status_unsafe() {
+        let mut emitter = GroupedEmitter::default()
+            .with_show_fix_status(true)
+            .with_show_source(true)
+            .with_unsafe_fixes(UnsafeFixes::Enabled);
+        let content = capture_emitter_output(&mut emitter, &create_messages());
+
+        assert_snapshot!(content);
+    }
 }

crates/ruff_linter/src/message/json.rs

@@ -5,7 +5,8 @@ use serde::{Serialize, Serializer};
 use serde_json::{json, Value};
 
 use ruff_diagnostics::Edit;
-use ruff_source_file::SourceCode;
+use ruff_notebook::NotebookIndex;
+use ruff_source_file::{OneIndexed, SourceCode, SourceLocation};
 use ruff_text_size::Ranged;
 
 use crate::message::{Emitter, EmitterContext, Message};
@@ -19,9 +20,9 @@ impl Emitter for JsonEmitter {
         &mut self,
         writer: &mut dyn Write,
         messages: &[Message],
-        _context: &EmitterContext,
+        context: &EmitterContext,
     ) -> anyhow::Result<()> {
-        serde_json::to_writer_pretty(writer, &ExpandedMessages { messages })?;
+        serde_json::to_writer_pretty(writer, &ExpandedMessages { messages, context })?;
 
         Ok(())
     }
@@ -29,6 +30,7 @@ impl Emitter for JsonEmitter {
 
 struct ExpandedMessages<'a> {
     messages: &'a [Message],
+    context: &'a EmitterContext<'a>,
 }
 
 impl Serialize for ExpandedMessages<'_> {
@@ -39,7 +41,7 @@ impl Serialize for ExpandedMessages<'_> {
         let mut s = serializer.serialize_seq(Some(self.messages.len()))?;
 
         for message in self.messages {
-            let value = message_to_json_value(message);
+            let value = message_to_json_value(message, self.context);
             s.serialize_element(&value)?;
         }
 
@@ -47,26 +49,40 @@ impl Serialize for ExpandedMessages<'_> {
     }
 }
 
-pub(crate) fn message_to_json_value(message: &Message) -> Value {
+pub(crate) fn message_to_json_value(message: &Message, context: &EmitterContext) -> Value {
     let source_code = message.file.to_source_code();
+    let notebook_index = context.notebook_index(message.filename());
 
     let fix = message.fix.as_ref().map(|fix| {
         json!({
             "applicability": fix.applicability(),
             "message": message.kind.suggestion.as_deref(),
-            "edits": &ExpandedEdits { edits: fix.edits(), source_code: &source_code },
+            "edits": &ExpandedEdits { edits: fix.edits(), source_code: &source_code, notebook_index },
         })
     });
 
-    let start_location = source_code.source_location(message.start());
-    let end_location = source_code.source_location(message.end());
-    let noqa_location = source_code.source_location(message.noqa_offset);
+    let mut start_location = source_code.source_location(message.start());
+    let mut end_location = source_code.source_location(message.end());
+    let mut noqa_location = source_code.source_location(message.noqa_offset);
+    let mut notebook_cell_index = None;
+
+    if let Some(notebook_index) = notebook_index {
+        notebook_cell_index = Some(
+            notebook_index
+                .cell(start_location.row)
+                .unwrap_or(OneIndexed::MIN),
+        );
+        start_location = notebook_index.translate_location(&start_location);
+        end_location = notebook_index.translate_location(&end_location);
+        noqa_location = notebook_index.translate_location(&noqa_location);
+    }
 
     json!({
         "code": message.kind.rule().noqa_code().to_string(),
         "url": message.kind.rule().url(),
         "message": message.kind.body,
         "fix": fix,
+        "cell": notebook_cell_index,
         "location": start_location,
         "end_location": end_location,
         "filename": message.filename(),
@@ -77,6 +93,7 @@ pub(crate) fn message_to_json_value(message: &Message) -> Value {
 struct ExpandedEdits<'a> {
     edits: &'a [Edit],
     source_code: &'a SourceCode<'a, 'a>,
+    notebook_index: Option<&'a NotebookIndex>,
 }
 
 impl Serialize for ExpandedEdits<'_> {
@@ -87,10 +104,57 @@ impl Serialize for ExpandedEdits<'_> {
         let mut s = serializer.serialize_seq(Some(self.edits.len()))?;
 
         for edit in self.edits {
+            let mut location = self.source_code.source_location(edit.start());
+            let mut end_location = self.source_code.source_location(edit.end());
+
+            if let Some(notebook_index) = self.notebook_index {
+                // There exists a newline between each cell's source code in the
+                // concatenated source code in Ruff. This newline doesn't actually
+                // exists in the JSON source field.
+                //
+                // Now, certain edits may try to remove this newline, which means
+                // the edit will spill over to the first character of the next cell.
+                // If it does, we need to translate the end location to the last
+                // character of the previous cell.
+                match (
+                    notebook_index.cell(location.row),
+                    notebook_index.cell(end_location.row),
+                ) {
+                    (Some(start_cell), Some(end_cell)) if start_cell != end_cell => {
+                        debug_assert_eq!(end_location.column.get(), 1);
+
+                        let prev_row = end_location.row.saturating_sub(1);
+                        end_location = SourceLocation {
+                            row: notebook_index.cell_row(prev_row).unwrap_or(OneIndexed::MIN),
+                            column: self
+                                .source_code
+                                .source_location(self.source_code.line_end_exclusive(prev_row))
+                                .column,
+                        };
+                    }
+                    (Some(_), None) => {
+                        debug_assert_eq!(end_location.column.get(), 1);
+
+                        let prev_row = end_location.row.saturating_sub(1);
+                        end_location = SourceLocation {
+                            row: notebook_index.cell_row(prev_row).unwrap_or(OneIndexed::MIN),
+                            column: self
+                                .source_code
+                                .source_location(self.source_code.line_end_exclusive(prev_row))
+                                .column,
+                        };
+                    }
+                    _ => {
+                        end_location = notebook_index.translate_location(&end_location);
+                    }
+                }
+                location = notebook_index.translate_location(&location);
+            }
+
             let value = json!({
                 "content": edit.content().unwrap_or_default(),
-                "location": self.source_code.source_location(edit.start()),
-                "end_location": self.source_code.source_location(edit.end())
+                "location": location,
+                "end_location": end_location
             });
 
             s.serialize_element(&value)?;
@@ -104,7 +168,10 @@ impl Serialize for ExpandedEdits<'_> {
 mod tests {
     use insta::assert_snapshot;
 
-    use crate::message::tests::{capture_emitter_output, create_messages};
+    use crate::message::tests::{
+        capture_emitter_notebook_output, capture_emitter_output, create_messages,
+        create_notebook_messages,
+    };
     use crate::message::JsonEmitter;
 
     #[test]
@@ -114,4 +181,13 @@ mod tests {
 
         assert_snapshot!(content);
     }
+
+    #[test]
+    fn notebook_output() {
+        let mut emitter = JsonEmitter;
+        let (messages, notebook_indexes) = create_notebook_messages();
+        let content = capture_emitter_notebook_output(&mut emitter, &messages, &notebook_indexes);
+
+        assert_snapshot!(content);
+    }
 }

crates/ruff_linter/src/message/json_lines.rs

@@ -11,11 +11,11 @@ impl Emitter for JsonLinesEmitter {
         &mut self,
         writer: &mut dyn Write,
         messages: &[Message],
-        _context: &EmitterContext,
+        context: &EmitterContext,
     ) -> anyhow::Result<()> {
         let mut w = writer;
         for message in messages {
-            serde_json::to_writer(&mut w, &message_to_json_value(message))?;
+            serde_json::to_writer(&mut w, &message_to_json_value(message, context))?;
             w.write_all(b"\n")?;
         }
         Ok(())
@@ -27,7 +27,10 @@ mod tests {
     use insta::assert_snapshot;
 
     use crate::message::json_lines::JsonLinesEmitter;
-    use crate::message::tests::{capture_emitter_output, create_messages};
+    use crate::message::tests::{
+        capture_emitter_notebook_output, capture_emitter_output, create_messages,
+        create_notebook_messages,
+    };
 
     #[test]
     fn output() {
@@ -36,4 +39,13 @@ mod tests {
 
         assert_snapshot!(content);
     }
+
+    #[test]
+    fn notebook_output() {
+        let mut emitter = JsonLinesEmitter;
+        let (messages, notebook_indexes) = create_notebook_messages();
+        let content = capture_emitter_notebook_output(&mut emitter, &messages, &notebook_indexes);
+
+        assert_snapshot!(content);
+    }
 }

crates/ruff_linter/src/message/mod.rs

@@ -150,7 +150,8 @@ mod tests {
     use rustc_hash::FxHashMap;
 
     use ruff_diagnostics::{Diagnostic, DiagnosticKind, Edit, Fix};
-    use ruff_source_file::SourceFileBuilder;
+    use ruff_notebook::NotebookIndex;
+    use ruff_source_file::{OneIndexed, SourceFileBuilder};
     use ruff_text_size::{Ranged, TextRange, TextSize};
 
     use crate::message::{Emitter, EmitterContext, Message};
@@ -178,7 +179,7 @@ def fibonacci(n):
             },
             TextRange::new(TextSize::from(7), TextSize::from(9)),
         )
-        .with_fix(Fix::suggested(Edit::range_deletion(TextRange::new(
+        .with_fix(Fix::unsafe_edit(Edit::range_deletion(TextRange::new(
             TextSize::from(0),
             TextSize::from(10),
         ))));
@@ -193,7 +194,7 @@ def fibonacci(n):
             },
             TextRange::new(TextSize::from(94), TextSize::from(95)),
         )
-        .with_fix(Fix::suggested(Edit::deletion(
+        .with_fix(Fix::unsafe_edit(Edit::deletion(
             TextSize::from(94),
             TextSize::from(99),
         )));
@@ -221,6 +222,113 @@ def fibonacci(n):
         ]
     }
 
+    pub(super) fn create_notebook_messages() -> (Vec<Message>, FxHashMap<String, NotebookIndex>) {
+        let notebook = r"# cell 1
+import os
+# cell 2
+import math
+
+print('hello world')
+# cell 3
+def foo():
+    print()
+    x = 1
+";
+
+        let unused_import_os = Diagnostic::new(
+            DiagnosticKind {
+                name: "UnusedImport".to_string(),
+                body: "`os` imported but unused".to_string(),
+                suggestion: Some("Remove unused import: `os`".to_string()),
+            },
+            TextRange::new(TextSize::from(16), TextSize::from(18)),
+        )
+        .with_fix(Fix::safe_edit(Edit::range_deletion(TextRange::new(
+            TextSize::from(9),
+            TextSize::from(19),
+        ))));
+
+        let unused_import_math = Diagnostic::new(
+            DiagnosticKind {
+                name: "UnusedImport".to_string(),
+                body: "`math` imported but unused".to_string(),
+                suggestion: Some("Remove unused import: `math`".to_string()),
+            },
+            TextRange::new(TextSize::from(35), TextSize::from(39)),
+        )
+        .with_fix(Fix::safe_edit(Edit::range_deletion(TextRange::new(
+            TextSize::from(28),
+            TextSize::from(40),
+        ))));
+
+        let unused_variable = Diagnostic::new(
+            DiagnosticKind {
+                name: "UnusedVariable".to_string(),
+                body: "Local variable `x` is assigned to but never used".to_string(),
+                suggestion: Some("Remove assignment to unused variable `x`".to_string()),
+            },
+            TextRange::new(TextSize::from(98), TextSize::from(99)),
+        )
+        .with_fix(Fix::unsafe_edit(Edit::deletion(
+            TextSize::from(94),
+            TextSize::from(104),
+        )));
+
+        let notebook_source = SourceFileBuilder::new("notebook.ipynb", notebook).finish();
+
+        let mut notebook_indexes = FxHashMap::default();
+        notebook_indexes.insert(
+            "notebook.ipynb".to_string(),
+            NotebookIndex::new(
+                vec![
+                    OneIndexed::from_zero_indexed(0),
+                    OneIndexed::from_zero_indexed(0),
+                    OneIndexed::from_zero_indexed(1),
+                    OneIndexed::from_zero_indexed(1),
+                    OneIndexed::from_zero_indexed(1),
+                    OneIndexed::from_zero_indexed(1),
+                    OneIndexed::from_zero_indexed(2),
+                    OneIndexed::from_zero_indexed(2),
+                    OneIndexed::from_zero_indexed(2),
+                    OneIndexed::from_zero_indexed(2),
+                ],
+                vec![
+                    OneIndexed::from_zero_indexed(0),
+                    OneIndexed::from_zero_indexed(1),
+                    OneIndexed::from_zero_indexed(0),
+                    OneIndexed::from_zero_indexed(1),
+                    OneIndexed::from_zero_indexed(2),
+                    OneIndexed::from_zero_indexed(3),
+                    OneIndexed::from_zero_indexed(0),
+                    OneIndexed::from_zero_indexed(1),
+                    OneIndexed::from_zero_indexed(2),
+                    OneIndexed::from_zero_indexed(3),
+                ],
+            ),
+        );
+
+        let unused_import_os_start = unused_import_os.start();
+        let unused_import_math_start = unused_import_math.start();
+        let unused_variable_start = unused_variable.start();
+
+        (
+            vec![
+                Message::from_diagnostic(
+                    unused_import_os,
+                    notebook_source.clone(),
+                    unused_import_os_start,
+                ),
+                Message::from_diagnostic(
+                    unused_import_math,
+                    notebook_source.clone(),
+                    unused_import_math_start,
+                ),
+                Message::from_diagnostic(unused_variable, notebook_source, unused_variable_start),
+            ],
+            notebook_indexes,
+        )
+    }
+
     pub(super) fn capture_emitter_output(
         emitter: &mut dyn Emitter,
         messages: &[Message],
@@ -232,4 +340,16 @@ def fibonacci(n):
 
         String::from_utf8(output).expect("Output to be valid UTF-8")
     }
+
+    pub(super) fn capture_emitter_notebook_output(
+        emitter: &mut dyn Emitter,
+        messages: &[Message],
+        notebook_indexes: &FxHashMap<String, NotebookIndex>,
+    ) -> String {
+        let context = EmitterContext::new(notebook_indexes);
+        let mut output: Vec<u8> = Vec::new();
+        emitter.emit(&mut output, messages, &context).unwrap();
+
+        String::from_utf8(output).expect("Output to be valid UTF-8")
+    }
 }

crates/ruff_linter/src/message/snapshots/ruff_linter__message__grouped__tests__fix_status.snap

@@ -3,14 +3,14 @@ source: crates/ruff_linter/src/message/grouped.rs
 expression: content
 ---
 fib.py:
-  1:8 F401 [*] `os` imported but unused
+  1:8 F401 `os` imported but unused
     |
   1 | import os
     |        ^^ F401
     |
     = help: Remove unused import: `os`
   
-  6:5 F841 [*] Local variable `x` is assigned to but never used
+  6:5 F841 Local variable `x` is assigned to but never used
     |
   4 | def fibonacci(n):
   5 |     """Compute the nth number in the Fibonacci sequence."""

crates/ruff_linter/src/message/snapshots/ruff_linter__message__grouped__tests__fix_status_unsafe.snap

@@ -0,0 +1,31 @@
+---
+source: crates/ruff_linter/src/message/grouped.rs
+expression: content
+---
+fib.py:
+  1:8 F401 [*] `os` imported but unused
+    |
+  1 | import os
+    |        ^^ F401
+    |
+    = help: Remove unused import: `os`
+  
+  6:5 F841 [*] Local variable `x` is assigned to but never used
+    |
+  4 | def fibonacci(n):
+  5 |     """Compute the nth number in the Fibonacci sequence."""
+  6 |     x = 1
+    |     ^ F841
+  7 |     if n == 0:
+  8 |         return 0
+    |
+    = help: Remove assignment to unused variable `x`
+  
+undef.py:
+  1:4 F821 Undefined name `a`
+    |
+  1 | if a == 1: pass
+    |    ^ F821
+    |
+  
+

crates/ruff_linter/src/message/snapshots/ruff_linter__message__json__tests__notebook_output.snap

@@ -0,0 +1,105 @@
+---
+source: crates/ruff_linter/src/message/json.rs
+expression: content
+---
+[
+  {
+    "cell": 1,
+    "code": "F401",
+    "end_location": {
+      "column": 10,
+      "row": 2
+    },
+    "filename": "notebook.ipynb",
+    "fix": {
+      "applicability": "safe",
+      "edits": [
+        {
+          "content": "",
+          "end_location": {
+            "column": 10,
+            "row": 2
+          },
+          "location": {
+            "column": 1,
+            "row": 2
+          }
+        }
+      ],
+      "message": "Remove unused import: `os`"
+    },
+    "location": {
+      "column": 8,
+      "row": 2
+    },
+    "message": "`os` imported but unused",
+    "noqa_row": 2,
+    "url": "https://docs.astral.sh/ruff/rules/unused-import"
+  },
+  {
+    "cell": 2,
+    "code": "F401",
+    "end_location": {
+      "column": 12,
+      "row": 2
+    },
+    "filename": "notebook.ipynb",
+    "fix": {
+      "applicability": "safe",
+      "edits": [
+        {
+          "content": "",
+          "end_location": {
+            "column": 1,
+            "row": 3
+          },
+          "location": {
+            "column": 1,
+            "row": 2
+          }
+        }
+      ],
+      "message": "Remove unused import: `math`"
+    },
+    "location": {
+      "column": 8,
+      "row": 2
+    },
+    "message": "`math` imported but unused",
+    "noqa_row": 2,
+    "url": "https://docs.astral.sh/ruff/rules/unused-import"
+  },
+  {
+    "cell": 3,
+    "code": "F841",
+    "end_location": {
+      "column": 6,
+      "row": 4
+    },
+    "filename": "notebook.ipynb",
+    "fix": {
+      "applicability": "unsafe",
+      "edits": [
+        {
+          "content": "",
+          "end_location": {
+            "column": 10,
+            "row": 4
+          },
+          "location": {
+            "column": 1,
+            "row": 4
+          }
+        }
+      ],
+      "message": "Remove assignment to unused variable `x`"
+    },
+    "location": {
+      "column": 5,
+      "row": 4
+    },
+    "message": "Local variable `x` is assigned to but never used",
+    "noqa_row": 4,
+    "url": "https://docs.astral.sh/ruff/rules/unused-variable"
+  }
+]

crates/ruff_linter/src/message/snapshots/ruff_linter__message__json__tests__output.snap

@@ -4,6 +4,7 @@ expression: content
 ---
 [
   {
+    "cell": null,
     "code": "F401",
     "end_location": {
       "column": 10,
@@ -11,7 +12,7 @@ expression: content
     },
     "filename": "fib.py",
     "fix": {
-      "applicability": "Suggested",
+      "applicability": "unsafe",
       "edits": [
         {
           "content": "",
@@ -36,6 +37,7 @@ expression: content
     "url": "https://docs.astral.sh/ruff/rules/unused-import"
   },
   {
+    "cell": null,
     "code": "F841",
     "end_location": {
       "column": 6,
@@ -43,7 +45,7 @@ expression: content
     },
     "filename": "fib.py",
     "fix": {
-      "applicability": "Suggested",
+      "applicability": "unsafe",
       "edits": [
         {
           "content": "",
@@ -68,6 +70,7 @@ expression: content
     "url": "https://docs.astral.sh/ruff/rules/unused-variable"
   },
   {
+    "cell": null,
     "code": "F821",
     "end_location": {
       "column": 5,

crates/ruff_linter/src/message/snapshots/ruff_linter__message__json_lines__tests__notebook_output.snap

@@ -0,0 +1,8 @@
+---
+source: crates/ruff_linter/src/message/json_lines.rs
+expression: content
+---
+{"cell":1,"code":"F401","end_location":{"column":10,"row":2},"filename":"notebook.ipynb","fix":{"applicability":"safe","edits":[{"content":"","end_location":{"column":10,"row":2},"location":{"column":1,"row":2}}],"message":"Remove unused import: `os`"},"location":{"column":8,"row":2},"message":"`os` imported but unused","noqa_row":2,"url":"https://docs.astral.sh/ruff/rules/unused-import"}
+{"cell":2,"code":"F401","end_location":{"column":12,"row":2},"filename":"notebook.ipynb","fix":{"applicability":"safe","edits":[{"content":"","end_location":{"column":1,"row":3},"location":{"column":1,"row":2}}],"message":"Remove unused import: `math`"},"location":{"column":8,"row":2},"message":"`math` imported but unused","noqa_row":2,"url":"https://docs.astral.sh/ruff/rules/unused-import"}
+{"cell":3,"code":"F841","end_location":{"column":6,"row":4},"filename":"notebook.ipynb","fix":{"applicability":"unsafe","edits":[{"content":"","end_location":{"column":10,"row":4},"location":{"column":1,"row":4}}],"message":"Remove assignment to unused variable `x`"},"location":{"column":5,"row":4},"message":"Local variable `x` is assigned to but never used","noqa_row":4,"url":"https://docs.astral.sh/ruff/rules/unused-variable"}
+

crates/ruff_linter/src/message/snapshots/ruff_linter__message__json_lines__tests__output.snap

@@ -2,7 +2,7 @@
 source: crates/ruff_linter/src/message/json_lines.rs
 expression: content
 ---
-{"code":"F401","end_location":{"column":10,"row":1},"filename":"fib.py","fix":{"applicability":"Suggested","edits":[{"content":"","end_location":{"column":1,"row":2},"location":{"column":1,"row":1}}],"message":"Remove unused import: `os`"},"location":{"column":8,"row":1},"message":"`os` imported but unused","noqa_row":1,"url":"https://docs.astral.sh/ruff/rules/unused-import"}
-{"code":"F841","end_location":{"column":6,"row":6},"filename":"fib.py","fix":{"applicability":"Suggested","edits":[{"content":"","end_location":{"column":10,"row":6},"location":{"column":5,"row":6}}],"message":"Remove assignment to unused variable `x`"},"location":{"column":5,"row":6},"message":"Local variable `x` is assigned to but never used","noqa_row":6,"url":"https://docs.astral.sh/ruff/rules/unused-variable"}
-{"code":"F821","end_location":{"column":5,"row":1},"filename":"undef.py","fix":null,"location":{"column":4,"row":1},"message":"Undefined name `a`","noqa_row":1,"url":"https://docs.astral.sh/ruff/rules/undefined-name"}
+{"cell":null,"code":"F401","end_location":{"column":10,"row":1},"filename":"fib.py","fix":{"applicability":"unsafe","edits":[{"content":"","end_location":{"column":1,"row":2},"location":{"column":1,"row":1}}],"message":"Remove unused import: `os`"},"location":{"column":8,"row":1},"message":"`os` imported but unused","noqa_row":1,"url":"https://docs.astral.sh/ruff/rules/unused-import"}
+{"cell":null,"code":"F841","end_location":{"column":6,"row":6},"filename":"fib.py","fix":{"applicability":"unsafe","edits":[{"content":"","end_location":{"column":10,"row":6},"location":{"column":5,"row":6}}],"message":"Remove assignment to unused variable `x`"},"location":{"column":5,"row":6},"message":"Local variable `x` is assigned to but never used","noqa_row":6,"url":"https://docs.astral.sh/ruff/rules/unused-variable"}
+{"cell":null,"code":"F821","end_location":{"column":5,"row":1},"filename":"undef.py","fix":null,"location":{"column":4,"row":1},"message":"Undefined name `a`","noqa_row":1,"url":"https://docs.astral.sh/ruff/rules/undefined-name"}
 

crates/ruff_linter/src/message/snapshots/ruff_linter__message__text__tests__fix_status.snap

@@ -2,14 +2,14 @@
 source: crates/ruff_linter/src/message/text.rs
 expression: content
 ---
-fib.py:1:8: F401 [*] `os` imported but unused
+fib.py:1:8: F401 `os` imported but unused
   |
 1 | import os
   |        ^^ F401
   |
   = help: Remove unused import: `os`
 
-fib.py:6:5: F841 [*] Local variable `x` is assigned to but never used
+fib.py:6:5: F841 Local variable `x` is assigned to but never used
   |
 4 | def fibonacci(n):
 5 |     """Compute the nth number in the Fibonacci sequence."""

crates/ruff_linter/src/message/snapshots/ruff_linter__message__text__tests__fix_status_unsafe.snap

@@ -0,0 +1,29 @@
+---
+source: crates/ruff_linter/src/message/text.rs
+expression: content
+---
+fib.py:1:8: F401 [*] `os` imported but unused
+  |
+1 | import os
+  |        ^^ F401
+  |
+  = help: Remove unused import: `os`
+
+fib.py:6:5: F841 [*] Local variable `x` is assigned to but never used
+  |
+4 | def fibonacci(n):
+5 |     """Compute the nth number in the Fibonacci sequence."""
+6 |     x = 1
+  |     ^ F841
+7 |     if n == 0:
+8 |         return 0
+  |
+  = help: Remove assignment to unused variable `x`
+
+undef.py:1:4: F821 Undefined name `a`
+  |
+1 | if a == 1: pass
+  |    ^ F821
+  |
+
+

crates/ruff_linter/src/message/snapshots/ruff_linter__message__text__tests__notebook_output.snap

@@ -0,0 +1,32 @@
+---
+source: crates/ruff_linter/src/message/text.rs
+expression: content
+---
+notebook.ipynb:cell 1:2:8: F401 [*] `os` imported but unused
+  |
+1 | # cell 1
+2 | import os
+  |        ^^ F401
+  |
+  = help: Remove unused import: `os`
+
+notebook.ipynb:cell 2:2:8: F401 [*] `math` imported but unused
+  |
+1 | # cell 2
+2 | import math
+  |        ^^^^ F401
+3 | 
+4 | print('hello world')
+  |
+  = help: Remove unused import: `math`
+
+notebook.ipynb:cell 3:4:5: F841 [*] Local variable `x` is assigned to but never used
+  |
+2 | def foo():
+3 |     print()
+4 |     x = 1
+  |     ^ F841
+  |
+  = help: Remove assignment to unused variable `x`
+
+

crates/ruff_linter/src/message/text.rs

@@ -16,22 +16,24 @@ use crate::line_width::{LineWidthBuilder, TabSize};
 use crate::message::diff::Diff;
 use crate::message::{Emitter, EmitterContext, Message};
 use crate::registry::AsRule;
+use crate::settings::types::UnsafeFixes;
 
 bitflags! {
     #[derive(Default)]
     struct EmitterFlags: u8 {
         /// Whether to show the fix status of a diagnostic.
-        const SHOW_FIX_STATUS = 0b0000_0001;
+        const SHOW_FIX_STATUS    = 0b0000_0001;
         /// Whether to show the diff of a fix, for diagnostics that have a fix.
-        const SHOW_FIX_DIFF   = 0b0000_0010;
+        const SHOW_FIX_DIFF      = 0b0000_0010;
         /// Whether to show the source code of a diagnostic.
-        const SHOW_SOURCE     = 0b0000_0100;
+        const SHOW_SOURCE        = 0b0000_0100;
     }
 }
 
 #[derive(Default)]
 pub struct TextEmitter {
     flags: EmitterFlags,
+    unsafe_fixes: UnsafeFixes,
 }
 
 impl TextEmitter {
@@ -53,6 +55,12 @@ impl TextEmitter {
         self.flags.set(EmitterFlags::SHOW_SOURCE, show_source);
         self
     }
+
+    #[must_use]
+    pub fn with_unsafe_fixes(mut self, unsafe_fixes: UnsafeFixes) -> Self {
+        self.unsafe_fixes = unsafe_fixes;
+        self
+    }
 }
 
 impl Emitter for TextEmitter {
@@ -79,18 +87,15 @@ impl Emitter for TextEmitter {
                     writer,
                     "cell {cell}{sep}",
                     cell = notebook_index
-                        .cell(start_location.row.get())
-                        .unwrap_or_default(),
+                        .cell(start_location.row)
+                        .unwrap_or(OneIndexed::MIN),
                     sep = ":".cyan(),
                 )?;
 
                 SourceLocation {
-                    row: OneIndexed::new(
-                        notebook_index
-                            .cell_row(start_location.row.get())
-                            .unwrap_or(1) as usize,
-                    )
-                    .unwrap(),
+                    row: notebook_index
+                        .cell_row(start_location.row)
+                        .unwrap_or(OneIndexed::MIN),
                     column: start_location.column,
                 }
             } else {
@@ -105,7 +110,8 @@ impl Emitter for TextEmitter {
                 sep = ":".cyan(),
                 code_and_body = RuleCodeAndBody {
                     message,
-                    show_fix_status: self.flags.intersects(EmitterFlags::SHOW_FIX_STATUS)
+                    show_fix_status: self.flags.intersects(EmitterFlags::SHOW_FIX_STATUS),
+                    unsafe_fixes: self.unsafe_fixes,
                 }
             )?;
 
@@ -134,28 +140,33 @@ impl Emitter for TextEmitter {
 pub(super) struct RuleCodeAndBody<'a> {
     pub(crate) message: &'a Message,
     pub(crate) show_fix_status: bool,
+    pub(crate) unsafe_fixes: UnsafeFixes,
 }
 
 impl Display for RuleCodeAndBody<'_> {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         let kind = &self.message.kind;
+        if self.show_fix_status {
+            if let Some(fix) = self.message.fix.as_ref() {
+                // Do not display an indicator for unapplicable fixes
+                if fix.applies(self.unsafe_fixes.required_applicability()) {
+                    return write!(
+                        f,
+                        "{code} {fix}{body}",
+                        code = kind.rule().noqa_code().to_string().red().bold(),
+                        fix = format_args!("[{}] ", "*".cyan()),
+                        body = kind.body,
+                    );
+                }
+            }
+        };
 
-        if self.show_fix_status && self.message.fix.is_some() {
-            write!(
-                f,
-                "{code} {fix}{body}",
-                code = kind.rule().noqa_code().to_string().red().bold(),
-                fix = format_args!("[{}] ", "*".cyan()),
-                body = kind.body,
-            )
-        } else {
-            write!(
-                f,
-                "{code} {body}",
-                code = kind.rule().noqa_code().to_string().red().bold(),
-                body = kind.body,
-            )
-        }
+        write!(
+            f,
+            "{code} {body}",
+            code = kind.rule().noqa_code().to_string().red().bold(),
+            body = kind.body,
+        )
     }
 }
 
@@ -189,9 +200,9 @@ impl Display for MessageCodeFrame<'_> {
         // If we're working with a Jupyter Notebook, skip the lines which are
         // outside of the cell containing the diagnostic.
         if let Some(index) = self.notebook_index {
-            let content_start_cell = index.cell(content_start_index.get()).unwrap_or_default();
+            let content_start_cell = index.cell(content_start_index).unwrap_or(OneIndexed::MIN);
             while start_index < content_start_index {
-                if index.cell(start_index.get()).unwrap_or_default() == content_start_cell {
+                if index.cell(start_index).unwrap_or(OneIndexed::MIN) == content_start_cell {
                     break;
                 }
                 start_index = start_index.saturating_add(1);
@@ -214,9 +225,9 @@ impl Display for MessageCodeFrame<'_> {
         // If we're working with a Jupyter Notebook, skip the lines which are
         // outside of the cell containing the diagnostic.
         if let Some(index) = self.notebook_index {
-            let content_end_cell = index.cell(content_end_index.get()).unwrap_or_default();
+            let content_end_cell = index.cell(content_end_index).unwrap_or(OneIndexed::MIN);
             while end_index > content_end_index {
-                if index.cell(end_index.get()).unwrap_or_default() == content_end_cell {
+                if index.cell(end_index).unwrap_or(OneIndexed::MIN) == content_end_cell {
                     break;
                 }
                 end_index = end_index.saturating_sub(1);
@@ -256,8 +267,9 @@ impl Display for MessageCodeFrame<'_> {
                     || start_index.get(),
                     |notebook_index| {
                         notebook_index
-                            .cell_row(start_index.get())
-                            .unwrap_or_default() as usize
+                            .cell_row(start_index)
+                            .unwrap_or(OneIndexed::MIN)
+                            .get()
                     },
                 ),
                 annotations: vec![SourceAnnotation {
@@ -339,8 +351,12 @@ struct SourceCode<'a> {
 mod tests {
     use insta::assert_snapshot;
 
-    use crate::message::tests::{capture_emitter_output, create_messages};
+    use crate::message::tests::{
+        capture_emitter_notebook_output, capture_emitter_output, create_messages,
+        create_notebook_messages,
+    };
     use crate::message::TextEmitter;
+    use crate::settings::types::UnsafeFixes;
 
     #[test]
     fn default() {
@@ -359,4 +375,27 @@ mod tests {
 
         assert_snapshot!(content);
     }
+
+    #[test]
+    fn fix_status_unsafe() {
+        let mut emitter = TextEmitter::default()
+            .with_show_fix_status(true)
+            .with_show_source(true)
+            .with_unsafe_fixes(UnsafeFixes::Enabled);
+        let content = capture_emitter_output(&mut emitter, &create_messages());
+
+        assert_snapshot!(content);
+    }
+
+    #[test]
+    fn notebook_output() {
+        let mut emitter = TextEmitter::default()
+            .with_show_fix_status(true)
+            .with_show_source(true)
+            .with_unsafe_fixes(UnsafeFixes::Enabled);
+        let (messages, notebook_indexes) = create_notebook_messages();
+        let content = capture_emitter_notebook_output(&mut emitter, &messages, &notebook_indexes);
+
+        assert_snapshot!(content);
+    }
 }

crates/ruff_linter/src/rules/eradicate/rules/commented_out_code.rs

@@ -3,7 +3,6 @@ use ruff_macros::{derive_message_formats, violation};
 use ruff_python_index::Indexer;
 use ruff_source_file::Locator;
 
-use crate::registry::Rule;
 use crate::settings::LinterSettings;
 
 use super::super::detection::comment_contains_code;
@@ -67,11 +66,9 @@ pub(crate) fn commented_out_code(
         if is_standalone_comment(line) && comment_contains_code(line, &settings.task_tags[..]) {
             let mut diagnostic = Diagnostic::new(CommentedOutCode, *range);
 
-            if settings.rules.should_fix(Rule::CommentedOutCode) {
-                diagnostic.set_fix(Fix::manual(Edit::range_deletion(
-                    locator.full_lines_range(*range),
-                )));
-            }
+            diagnostic.set_fix(Fix::display_edit(Edit::range_deletion(
+                locator.full_lines_range(*range),
+            )));
             diagnostics.push(diagnostic);
         }
     }

crates/ruff_linter/src/rules/eradicate/snapshots/ruff_linter__rules__eradicate__tests__ERA001_ERA001.py.snap

@@ -1,7 +1,7 @@
 ---
 source: crates/ruff_linter/src/rules/eradicate/mod.rs
 ---
-ERA001.py:1:1: ERA001 [*] Found commented-out code
+ERA001.py:1:1: ERA001 Found commented-out code
   |
 1 | #import os
   | ^^^^^^^^^^ ERA001
@@ -16,7 +16,7 @@ ERA001.py:1:1: ERA001 [*] Found commented-out code
 3 2 | #a = 3
 4 3 | a = 4
 
-ERA001.py:2:1: ERA001 [*] Found commented-out code
+ERA001.py:2:1: ERA001 Found commented-out code
   |
 1 | #import os
 2 | # from foo import junk
@@ -33,7 +33,7 @@ ERA001.py:2:1: ERA001 [*] Found commented-out code
 4 3 | a = 4
 5 4 | #foo(1, 2, 3)
 
-ERA001.py:3:1: ERA001 [*] Found commented-out code
+ERA001.py:3:1: ERA001 Found commented-out code
   |
 1 | #import os
 2 | # from foo import junk
@@ -52,7 +52,7 @@ ERA001.py:3:1: ERA001 [*] Found commented-out code
 5 4 | #foo(1, 2, 3)
 6 5 | 
 
-ERA001.py:5:1: ERA001 [*] Found commented-out code
+ERA001.py:5:1: ERA001 Found commented-out code
   |
 3 | #a = 3
 4 | a = 4
@@ -72,7 +72,7 @@ ERA001.py:5:1: ERA001 [*] Found commented-out code
 7 6 | def foo(x, y, z):
 8 7 |     content = 1 # print('hello')
 
-ERA001.py:13:5: ERA001 [*] Found commented-out code
+ERA001.py:13:5: ERA001 Found commented-out code
    |
 11 |     # This is a real comment.
 12 |     # # This is a (nested) comment.
@@ -91,7 +91,7 @@ ERA001.py:13:5: ERA001 [*] Found commented-out code
 15 14 | 
 16 15 | #import os  # noqa: ERA001
 
-ERA001.py:21:5: ERA001 [*] Found commented-out code
+ERA001.py:21:5: ERA001 Found commented-out code
    |
 19 | class A():
 20 |     pass
@@ -109,7 +109,7 @@ ERA001.py:21:5: ERA001 [*] Found commented-out code
 23 22 | 
 24 23 | dictionary = {
 
-ERA001.py:26:5: ERA001 [*] Found commented-out code
+ERA001.py:26:5: ERA001 Found commented-out code
    |
 24 | dictionary = {
 25 |     # "key1": 123,  # noqa: ERA001
@@ -129,7 +129,7 @@ ERA001.py:26:5: ERA001 [*] Found commented-out code
 28 27 | }
 29 28 | 
 
-ERA001.py:27:5: ERA001 [*] Found commented-out code
+ERA001.py:27:5: ERA001 Found commented-out code
    |
 25 |     # "key1": 123,  # noqa: ERA001
 26 |     # "key2": 456,

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

@@ -11,7 +11,7 @@ use ruff_python_stdlib::typing::simple_magic_return_type;
 use ruff_text_size::Ranged;
 
 use crate::checkers::ast::Checker;
-use crate::registry::{AsRule, Rule};
+use crate::registry::Rule;
 use crate::rules::ruff::typing::type_hint_resolves_to_any;
 
 /// ## What it does
@@ -702,12 +702,10 @@ pub(crate) fn definition(
                         },
                         function.identifier(),
                     );
-                    if checker.patch(diagnostic.kind.rule()) {
-                        diagnostic.set_fix(Fix::suggested(Edit::insertion(
-                            " -> None".to_string(),
-                            function.parameters.range().end(),
-                        )));
-                    }
+                    diagnostic.set_fix(Fix::unsafe_edit(Edit::insertion(
+                        " -> None".to_string(),
+                        function.parameters.range().end(),
+                    )));
                     diagnostics.push(diagnostic);
                 }
             }
@@ -719,13 +717,11 @@ pub(crate) fn definition(
                     },
                     function.identifier(),
                 );
-                if checker.patch(diagnostic.kind.rule()) {
-                    if let Some(return_type) = simple_magic_return_type(name) {
-                        diagnostic.set_fix(Fix::suggested(Edit::insertion(
-                            format!(" -> {return_type}"),
-                            function.parameters.range().end(),
-                        )));
-                    }
+                if let Some(return_type) = simple_magic_return_type(name) {
+                    diagnostic.set_fix(Fix::unsafe_edit(Edit::insertion(
+                        format!(" -> {return_type}"),
+                        function.parameters.range().end(),
+                    )));
                 }
                 diagnostics.push(diagnostic);
             }

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

@@ -12,6 +12,7 @@ pub(super) fn is_allowed_func_call(name: &str) -> bool {
             | "assertNotEquals"
             | "bool"
             | "bytes"
+            | "coalesce"
             | "count"
             | "failIfEqual"
             | "failUnlessEqual"
@@ -22,12 +23,15 @@ pub(super) fn is_allowed_func_call(name: &str) -> bool {
             | "getboolean"
             | "getfloat"
             | "getint"
+            | "ifnull"
             | "index"
             | "insert"
             | "int"
             | "is_"
             | "is_not"
+            | "isnull"
             | "next"
+            | "nvl"
             | "param"
             | "pop"
             | "remove"

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:87:19: FBT001 Boolean-typed positional argument in function definition
+FBT.py:89:19: FBT001 Boolean-typed positional argument in function definition
    |
-86 |     # FBT001: Boolean positional arg in function definition
-87 |     def foo(self, value: bool) -> None:
+88 |     # FBT001: Boolean positional arg in function definition
+89 |     def foo(self, value: bool) -> None:
    |                   ^^^^^ FBT001
-88 |         pass
+90 |         pass
    |
 
 

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

@@ -6,7 +6,6 @@ use ruff_macros::{derive_message_formats, violation};
 use ruff_python_ast::helpers::is_const_false;
 
 use crate::checkers::ast::Checker;
-use crate::registry::AsRule;
 
 /// ## What it does
 /// Checks for uses of `assert False`.
@@ -75,11 +74,9 @@ pub(crate) fn assert_false(checker: &mut Checker, stmt: &Stmt, test: &Expr, msg:
     }
 
     let mut diagnostic = Diagnostic::new(AssertFalse, test.range());
-    if checker.patch(diagnostic.kind.rule()) {
-        diagnostic.set_fix(Fix::suggested(Edit::range_replacement(
-            checker.generator().stmt(&assertion_error(msg)),
-            stmt.range(),
-        )));
-    }
+    diagnostic.set_fix(Fix::unsafe_edit(Edit::range_replacement(
+        checker.generator().stmt(&assertion_error(msg)),
+        stmt.range(),
+    )));
     checker.diagnostics.push(diagnostic);
 }

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

@@ -11,7 +11,7 @@ use ruff_python_ast::call_path::CallPath;
 
 use crate::checkers::ast::Checker;
 use crate::fix::edits::pad;
-use crate::registry::{AsRule, Rule};
+use crate::registry::Rule;
 
 /// ## What it does
 /// Checks for `try-except` blocks with duplicate exception handlers.
@@ -146,24 +146,22 @@ fn duplicate_handler_exceptions<'a>(
                 },
                 expr.range(),
             );
-            if checker.patch(diagnostic.kind.rule()) {
-                diagnostic.set_fix(Fix::automatic(Edit::range_replacement(
-                    // Single exceptions don't require parentheses, but since we're _removing_
-                    // parentheses, insert whitespace as needed.
-                    if let [elt] = unique_elts.as_slice() {
-                        pad(
-                            checker.generator().expr(elt),
-                            expr.range(),
-                            checker.locator(),
-                        )
-                    } else {
-                        // Multiple exceptions must always be parenthesized. This is done
-                        // manually as the generator never parenthesizes lone tuples.
-                        format!("({})", checker.generator().expr(&type_pattern(unique_elts)))
-                    },
-                    expr.range(),
-                )));
-            }
+            diagnostic.set_fix(Fix::safe_edit(Edit::range_replacement(
+                // Single exceptions don't require parentheses, but since we're _removing_
+                // parentheses, insert whitespace as needed.
+                if let [elt] = unique_elts.as_slice() {
+                    pad(
+                        checker.generator().expr(elt),
+                        expr.range(),
+                        checker.locator(),
+                    )
+                } else {
+                    // Multiple exceptions must always be parenthesized. This is done
+                    // manually as the generator never parenthesizes lone tuples.
+                    format!("({})", checker.generator().expr(&type_pattern(unique_elts)))
+                },
+                expr.range(),
+            )));
             checker.diagnostics.push(diagnostic);
         }
     }

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

@@ -6,7 +6,6 @@ use ruff_python_stdlib::identifiers::{is_identifier, is_mangled_private};
 use ruff_text_size::Ranged;
 
 use crate::checkers::ast::Checker;
-use crate::registry::AsRule;
 
 /// ## What it does
 /// Checks for uses of `getattr` that take a constant attribute value as an
@@ -85,26 +84,24 @@ pub(crate) fn getattr_with_constant(
     }
 
     let mut diagnostic = Diagnostic::new(GetAttrWithConstant, expr.range());
-    if checker.patch(diagnostic.kind.rule()) {
-        diagnostic.set_fix(Fix::suggested(Edit::range_replacement(
-            pad(
-                if matches!(
-                    obj,
-                    Expr::Name(_) | Expr::Attribute(_) | Expr::Subscript(_) | Expr::Call(_)
-                ) && !checker.locator().contains_line_break(obj.range())
-                {
-                    format!("{}.{}", checker.locator().slice(obj), value)
-                } else {
-                    // Defensively parenthesize any other expressions. For example, attribute accesses
-                    // on `int` literals must be parenthesized, e.g., `getattr(1, "real")` becomes
-                    // `(1).real`. The same is true for named expressions and others.
-                    format!("({}).{}", checker.locator().slice(obj), value)
-                },
-                expr.range(),
-                checker.locator(),
-            ),
+    diagnostic.set_fix(Fix::safe_edit(Edit::range_replacement(
+        pad(
+            if matches!(
+                obj,
+                Expr::Name(_) | Expr::Attribute(_) | Expr::Subscript(_) | Expr::Call(_)
+            ) && !checker.locator().contains_line_break(obj.range())
+            {
+                format!("{}.{}", checker.locator().slice(obj), value)
+            } else {
+                // Defensively parenthesize any other expressions. For example, attribute accesses
+                // on `int` literals must be parenthesized, e.g., `getattr(1, "real")` becomes
+                // `(1).real`. The same is true for named expressions and others.
+                format!("({}).{}", checker.locator().slice(obj), value)
+            },
             expr.range(),
-        )));
-    }
+            checker.locator(),
+        ),
+        expr.range(),
+    )));
     checker.diagnostics.push(diagnostic);
 }

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

@@ -11,7 +11,6 @@ use ruff_source_file::Locator;
 use ruff_text_size::Ranged;
 
 use crate::checkers::ast::Checker;
-use crate::registry::AsRule;
 
 /// ## What it does
 /// Checks for uses of mutable objects as function argument defaults.
@@ -110,18 +109,16 @@ pub(crate) fn mutable_argument_default(checker: &mut Checker, function_def: &ast
             let mut diagnostic = Diagnostic::new(MutableArgumentDefault, default.range());
 
             // If the function body is on the same line as the function def, do not fix
-            if checker.patch(diagnostic.kind.rule()) {
-                if let Some(fix) = move_initialization(
-                    function_def,
-                    parameter,
-                    default,
-                    checker.locator(),
-                    checker.stylist(),
-                    checker.indexer(),
-                    checker.generator(),
-                ) {
-                    diagnostic.set_fix(fix);
-                }
+            if let Some(fix) = move_initialization(
+                function_def,
+                parameter,
+                default,
+                checker.locator(),
+                checker.stylist(),
+                checker.indexer(),
+                checker.generator(),
+            ) {
+                diagnostic.set_fix(fix);
             }
             checker.diagnostics.push(diagnostic);
         }
@@ -200,5 +197,5 @@ fn move_initialization(
     }
 
     let initialization_edit = Edit::insertion(content, pos);
-    Some(Fix::manual_edits(default_edit, [initialization_edit]))
+    Some(Fix::display_edits(default_edit, [initialization_edit]))
 }

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

@@ -6,7 +6,6 @@ use ruff_text_size::Ranged;
 
 use crate::checkers::ast::Checker;
 use crate::fix::edits::pad;
-use crate::registry::AsRule;
 
 /// ## What it does
 /// Checks for single-element tuples in exception handlers (e.g.,
@@ -77,23 +76,21 @@ pub(crate) fn redundant_tuple_in_exception_handler(
             },
             type_.range(),
         );
-        if checker.patch(diagnostic.kind.rule()) {
-            // If there's no space between the `except` and the tuple, we need to insert a space,
-            // as in:
-            // ```python
-            // except(ValueError,):
-            // ```
-            // Otherwise, the output will be invalid syntax, since we're removing a set of
-            // parentheses.
-            diagnostic.set_fix(Fix::automatic(Edit::range_replacement(
-                pad(
-                    checker.generator().expr(elt),
-                    type_.range(),
-                    checker.locator(),
-                ),
+        // If there's no space between the `except` and the tuple, we need to insert a space,
+        // as in:
+        // ```python
+        // except(ValueError,):
+        // ```
+        // Otherwise, the output will be invalid syntax, since we're removing a set of
+        // parentheses.
+        diagnostic.set_fix(Fix::safe_edit(Edit::range_replacement(
+            pad(
+                checker.generator().expr(elt),
                 type_.range(),
-            )));
-        }
+                checker.locator(),
+            ),
+            type_.range(),
+        )));
         checker.diagnostics.push(diagnostic);
     }
 }

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

@@ -7,7 +7,6 @@ use ruff_python_codegen::Generator;
 use ruff_python_stdlib::identifiers::{is_identifier, is_mangled_private};
 
 use crate::checkers::ast::Checker;
-use crate::registry::AsRule;
 
 /// ## What it does
 /// Checks for uses of `setattr` that take a constant attribute value as an
@@ -108,12 +107,10 @@ pub(crate) fn setattr_with_constant(
     {
         if expr == child.as_ref() {
             let mut diagnostic = Diagnostic::new(SetAttrWithConstant, expr.range());
-            if checker.patch(diagnostic.kind.rule()) {
-                diagnostic.set_fix(Fix::suggested(Edit::range_replacement(
-                    assignment(obj, name, value, checker.generator()),
-                    expr.range(),
-                )));
-            }
+            diagnostic.set_fix(Fix::safe_edit(Edit::range_replacement(
+                assignment(obj, name, value, checker.generator()),
+                expr.range(),
+            )));
             checker.diagnostics.push(diagnostic);
         }
     }

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

@@ -5,7 +5,6 @@ use ruff_macros::{derive_message_formats, violation};
 use ruff_text_size::Ranged;
 
 use crate::checkers::ast::Checker;
-use crate::registry::AsRule;
 
 /// ## What it does
 /// Checks for uses of `hasattr` to test if an object is callable (e.g.,
@@ -80,14 +79,12 @@ pub(crate) fn unreliable_callable_check(
     }
 
     let mut diagnostic = Diagnostic::new(UnreliableCallableCheck, expr.range());
-    if checker.patch(diagnostic.kind.rule()) {
-        if id == "hasattr" {
-            if checker.semantic().is_builtin("callable") {
-                diagnostic.set_fix(Fix::automatic(Edit::range_replacement(
-                    format!("callable({})", checker.locator().slice(obj)),
-                    expr.range(),
-                )));
-            }
+    if id == "hasattr" {
+        if checker.semantic().is_builtin("callable") {
+            diagnostic.set_fix(Fix::safe_edit(Edit::range_replacement(
+                format!("callable({})", checker.locator().slice(obj)),
+                expr.range(),
+            )));
         }
     }
     checker.diagnostics.push(diagnostic);

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

@@ -8,7 +8,6 @@ use ruff_python_ast::{helpers, visitor};
 use ruff_text_size::Ranged;
 
 use crate::checkers::ast::Checker;
-use crate::registry::AsRule;
 
 #[derive(Debug, Copy, Clone, PartialEq, Eq, result_like::BoolLike)]
 enum Certainty {
@@ -156,23 +155,21 @@ pub(crate) fn unused_loop_control_variable(checker: &mut Checker, stmt_for: &ast
             },
             expr.range(),
         );
-        if checker.patch(diagnostic.kind.rule()) {
-            if let Some(rename) = rename {
-                if certainty.into() {
-                    // Avoid fixing if the variable, or any future bindings to the variable, are
-                    // used _after_ the loop.
-                    let scope = checker.semantic().current_scope();
-                    if scope
-                        .get_all(name)
-                        .map(|binding_id| checker.semantic().binding(binding_id))
-                        .filter(|binding| binding.start() >= expr.start())
-                        .all(|binding| !binding.is_used())
-                    {
-                        diagnostic.set_fix(Fix::suggested(Edit::range_replacement(
-                            rename,
-                            expr.range(),
-                        )));
-                    }
+        if let Some(rename) = rename {
+            if certainty.into() {
+                // Avoid fixing if the variable, or any future bindings to the variable, are
+                // used _after_ the loop.
+                let scope = checker.semantic().current_scope();
+                if scope
+                    .get_all(name)
+                    .map(|binding_id| checker.semantic().binding(binding_id))
+                    .filter(|binding| binding.start() >= expr.start())
+                    .all(|binding| !binding.is_used())
+                {
+                    diagnostic.set_fix(Fix::unsafe_edit(Edit::range_replacement(
+                        rename,
+                        expr.range(),
+                    )));
                 }
             }
         }

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

@@ -1,7 +1,7 @@
 ---
 source: crates/ruff_linter/src/rules/flake8_bugbear/mod.rs
 ---
-B006_1.py:3:22: B006 [*] Do not use mutable data structures for argument defaults
+B006_1.py:3:22: B006 Do not use mutable data structures for argument defaults
   |
 1 | # Docstring followed by a newline
 2 | 

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

@@ -1,7 +1,7 @@
 ---
 source: crates/ruff_linter/src/rules/flake8_bugbear/mod.rs
 ---
-B006_2.py:4:22: B006 [*] Do not use mutable data structures for argument defaults
+B006_2.py:4:22: B006 Do not use mutable data structures for argument defaults
   |
 2 | # Regression test for https://github.com/astral-sh/ruff/issues/7155
 3 | 

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

@@ -1,7 +1,7 @@
 ---
 source: crates/ruff_linter/src/rules/flake8_bugbear/mod.rs
 ---
-B006_3.py:4:22: B006 [*] Do not use mutable data structures for argument defaults
+B006_3.py:4:22: B006 Do not use mutable data structures for argument defaults
   |
 4 | def foobar(foor, bar={}):    
   |                      ^^ B006

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

@@ -1,7 +1,7 @@
 ---
 source: crates/ruff_linter/src/rules/flake8_bugbear/mod.rs
 ---
-B006_4.py:7:26: B006 [*] Do not use mutable data structures for argument defaults
+B006_4.py:7:26: B006 Do not use mutable data structures for argument defaults
   |
 6 | class FormFeedIndent:
 7 |    def __init__(self, a=[]):

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

@@ -1,7 +1,7 @@
 ---
 source: crates/ruff_linter/src/rules/flake8_bugbear/mod.rs
 ---
-B006_5.py:5:49: B006 [*] Do not use mutable data structures for argument defaults
+B006_5.py:5:49: B006 Do not use mutable data structures for argument defaults
   |
 5 | def import_module_wrong(value: dict[str, str] = {}):
   |                                                 ^^ B006
@@ -22,7 +22,7 @@ B006_5.py:5:49: B006 [*] Do not use mutable data structures for argument default
 8 10 | 
 9 11 | def import_module_with_values_wrong(value: dict[str, str] = {}):
 
-B006_5.py:9:61: B006 [*] Do not use mutable data structures for argument defaults
+B006_5.py:9:61: B006 Do not use mutable data structures for argument defaults
    |
  9 | def import_module_with_values_wrong(value: dict[str, str] = {}):
    |                                                             ^^ B006
@@ -44,7 +44,7 @@ B006_5.py:9:61: B006 [*] Do not use mutable data structures for argument default
 13 15 | 
 14 16 | 
 
-B006_5.py:15:50: B006 [*] Do not use mutable data structures for argument defaults
+B006_5.py:15:50: B006 Do not use mutable data structures for argument defaults
    |
 15 | def import_modules_wrong(value: dict[str, str] = {}):
    |                                                  ^^ B006
@@ -68,7 +68,7 @@ B006_5.py:15:50: B006 [*] Do not use mutable data structures for argument defaul
 20 22 | 
 21 23 | def from_import_module_wrong(value: dict[str, str] = {}):
 
-B006_5.py:21:54: B006 [*] Do not use mutable data structures for argument defaults
+B006_5.py:21:54: B006 Do not use mutable data structures for argument defaults
    |
 21 | def from_import_module_wrong(value: dict[str, str] = {}):
    |                                                      ^^ B006
@@ -89,7 +89,7 @@ B006_5.py:21:54: B006 [*] Do not use mutable data structures for argument defaul
 24 26 | 
 25 27 | def from_imports_module_wrong(value: dict[str, str] = {}):
 
-B006_5.py:25:55: B006 [*] Do not use mutable data structures for argument defaults
+B006_5.py:25:55: B006 Do not use mutable data structures for argument defaults
    |
 25 | def from_imports_module_wrong(value: dict[str, str] = {}):
    |                                                       ^^ B006
@@ -112,7 +112,7 @@ B006_5.py:25:55: B006 [*] Do not use mutable data structures for argument defaul
 29 31 | 
 30 32 | def import_and_from_imports_module_wrong(value: dict[str, str] = {}):
 
-B006_5.py:30:66: B006 [*] Do not use mutable data structures for argument defaults
+B006_5.py:30:66: B006 Do not use mutable data structures for argument defaults
    |
 30 | def import_and_from_imports_module_wrong(value: dict[str, str] = {}):
    |                                                                  ^^ B006
@@ -135,7 +135,7 @@ B006_5.py:30:66: B006 [*] Do not use mutable data structures for argument defaul
 34 36 | 
 35 37 | def import_docstring_module_wrong(value: dict[str, str] = {}):
 
-B006_5.py:35:59: B006 [*] Do not use mutable data structures for argument defaults
+B006_5.py:35:59: B006 Do not use mutable data structures for argument defaults
    |
 35 | def import_docstring_module_wrong(value: dict[str, str] = {}):
    |                                                           ^^ B006
@@ -158,7 +158,7 @@ B006_5.py:35:59: B006 [*] Do not use mutable data structures for argument defaul
 39 41 | 
 40 42 | def import_module_wrong(value: dict[str, str] = {}):
 
-B006_5.py:40:49: B006 [*] Do not use mutable data structures for argument defaults
+B006_5.py:40:49: B006 Do not use mutable data structures for argument defaults
    |
 40 | def import_module_wrong(value: dict[str, str] = {}):
    |                                                 ^^ B006
@@ -181,7 +181,7 @@ B006_5.py:40:49: B006 [*] Do not use mutable data structures for argument defaul
 44 46 | 
 45 47 | def import_module_wrong(value: dict[str, str] = {}):
 
-B006_5.py:45:49: B006 [*] Do not use mutable data structures for argument defaults
+B006_5.py:45:49: B006 Do not use mutable data structures for argument defaults
    |
 45 | def import_module_wrong(value: dict[str, str] = {}):
    |                                                 ^^ B006
@@ -203,7 +203,7 @@ B006_5.py:45:49: B006 [*] Do not use mutable data structures for argument defaul
 48 50 | 
 49 51 | 
 
-B006_5.py:50:49: B006 [*] Do not use mutable data structures for argument defaults
+B006_5.py:50:49: B006 Do not use mutable data structures for argument defaults
    |
 50 | def import_module_wrong(value: dict[str, str] = {}):
    |                                                 ^^ B006
@@ -226,7 +226,7 @@ B006_5.py:50:49: B006 [*] Do not use mutable data structures for argument defaul
 54 56 | 
 55 57 | def import_module_wrong(value: dict[str, str] = {}):
 
-B006_5.py:55:49: B006 [*] Do not use mutable data structures for argument defaults
+B006_5.py:55:49: B006 Do not use mutable data structures for argument defaults
    |
 55 | def import_module_wrong(value: dict[str, str] = {}):
    |                                                 ^^ B006
@@ -247,7 +247,7 @@ B006_5.py:55:49: B006 [*] Do not use mutable data structures for argument defaul
 58 60 | 
 59 61 | def import_module_wrong(value: dict[str, str] = {}):
 
-B006_5.py:59:49: B006 [*] Do not use mutable data structures for argument defaults
+B006_5.py:59:49: B006 Do not use mutable data structures for argument defaults
    |
 59 | def import_module_wrong(value: dict[str, str] = {}):
    |                                                 ^^ B006
@@ -267,7 +267,7 @@ B006_5.py:59:49: B006 [*] Do not use mutable data structures for argument defaul
 61 63 | 
 62 64 | 
 
-B006_5.py:63:49: B006 [*] Do not use mutable data structures for argument defaults
+B006_5.py:63:49: B006 Do not use mutable data structures for argument defaults
    |
 63 | def import_module_wrong(value: dict[str, str] = {}):
    |                                                 ^^ B006

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

@@ -1,7 +1,7 @@
 ---
 source: crates/ruff_linter/src/rules/flake8_bugbear/mod.rs
 ---
-B006_6.py:4:22: B006 [*] Do not use mutable data structures for argument defaults
+B006_6.py:4:22: B006 Do not use mutable data structures for argument defaults
   |
 2 | # Same as B006_2.py, but import instead of docstring
 3 | 

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

@@ -1,7 +1,7 @@
 ---
 source: crates/ruff_linter/src/rules/flake8_bugbear/mod.rs
 ---
-B006_7.py:4:22: B006 [*] Do not use mutable data structures for argument defaults
+B006_7.py:4:22: B006 Do not use mutable data structures for argument defaults
   |
 2 | # Same as B006_3.py, but import instead of docstring
 3 | 

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

@@ -1,7 +1,7 @@
 ---
 source: crates/ruff_linter/src/rules/flake8_bugbear/mod.rs
 ---
-B006_B008.py:63:25: B006 [*] Do not use mutable data structures for argument defaults
+B006_B008.py:63:25: B006 Do not use mutable data structures for argument defaults
    |
 63 | def this_is_wrong(value=[1, 2, 3]):
    |                         ^^^^^^^^^ B006
@@ -21,7 +21,7 @@ B006_B008.py:63:25: B006 [*] Do not use mutable data structures for argument def
 65 67 | 
 66 68 | 
 
-B006_B008.py:67:30: B006 [*] Do not use mutable data structures for argument defaults
+B006_B008.py:67:30: B006 Do not use mutable data structures for argument defaults
    |
 67 | def this_is_also_wrong(value={}):
    |                              ^^ B006
@@ -41,7 +41,7 @@ B006_B008.py:67:30: B006 [*] Do not use mutable data structures for argument def
 69 71 | 
 70 72 | 
 
-B006_B008.py:73:52: B006 [*] Do not use mutable data structures for argument defaults
+B006_B008.py:73:52: B006 Do not use mutable data structures for argument defaults
    |
 71 | class Foo:
 72 |     @staticmethod
@@ -63,7 +63,7 @@ B006_B008.py:73:52: B006 [*] Do not use mutable data structures for argument def
 75 77 | 
 76 78 | 
 
-B006_B008.py:77:31: B006 [*] Do not use mutable data structures for argument defaults
+B006_B008.py:77:31: B006 Do not use mutable data structures for argument defaults
    |
 77 |   def multiline_arg_wrong(value={
    |  _______________________________^
@@ -97,7 +97,7 @@ B006_B008.py:82:36: B006 Do not use mutable data structures for argument default
    |
    = help: Replace with `None`; initialize within function
 
-B006_B008.py:85:20: B006 [*] Do not use mutable data structures for argument defaults
+B006_B008.py:85:20: B006 Do not use mutable data structures for argument defaults
    |
 85 | def and_this(value=set()):
    |                    ^^^^^ B006
@@ -117,7 +117,7 @@ B006_B008.py:85:20: B006 [*] Do not use mutable data structures for argument def
 87 89 | 
 88 90 | 
 
-B006_B008.py:89:20: B006 [*] Do not use mutable data structures for argument defaults
+B006_B008.py:89:20: B006 Do not use mutable data structures for argument defaults
    |
 89 | def this_too(value=collections.OrderedDict()):
    |                    ^^^^^^^^^^^^^^^^^^^^^^^^^ B006
@@ -137,7 +137,7 @@ B006_B008.py:89:20: B006 [*] Do not use mutable data structures for argument def
 91 93 | 
 92 94 | 
 
-B006_B008.py:93:32: B006 [*] Do not use mutable data structures for argument defaults
+B006_B008.py:93:32: B006 Do not use mutable data structures for argument defaults
    |
 93 | async def async_this_too(value=collections.defaultdict()):
    |                                ^^^^^^^^^^^^^^^^^^^^^^^^^ B006
@@ -157,7 +157,7 @@ B006_B008.py:93:32: B006 [*] Do not use mutable data structures for argument def
 95 97 | 
 96 98 | 
 
-B006_B008.py:97:26: B006 [*] Do not use mutable data structures for argument defaults
+B006_B008.py:97:26: B006 Do not use mutable data structures for argument defaults
    |
 97 | def dont_forget_me(value=collections.deque()):
    |                          ^^^^^^^^^^^^^^^^^^^ B006
@@ -177,7 +177,7 @@ B006_B008.py:97:26: B006 [*] Do not use mutable data structures for argument def
 99  101 | 
 100 102 | 
 
-B006_B008.py:102:46: B006 [*] Do not use mutable data structures for argument defaults
+B006_B008.py:102:46: B006 Do not use mutable data structures for argument defaults
     |
 101 | # N.B. we're also flagging the function call in the comprehension
 102 | def list_comprehension_also_not_okay(default=[i**2 for i in range(3)]):
@@ -198,7 +198,7 @@ B006_B008.py:102:46: B006 [*] Do not use mutable data structures for argument de
 104 106 | 
 105 107 | 
 
-B006_B008.py:106:46: B006 [*] Do not use mutable data structures for argument defaults
+B006_B008.py:106:46: B006 Do not use mutable data structures for argument defaults
     |
 106 | def dict_comprehension_also_not_okay(default={i: i**2 for i in range(3)}):
     |                                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^ B006
@@ -218,7 +218,7 @@ B006_B008.py:106:46: B006 [*] Do not use mutable data structures for argument de
 108 110 | 
 109 111 | 
 
-B006_B008.py:110:45: B006 [*] Do not use mutable data structures for argument defaults
+B006_B008.py:110:45: B006 Do not use mutable data structures for argument defaults
     |
 110 | def set_comprehension_also_not_okay(default={i**2 for i in range(3)}):
     |                                             ^^^^^^^^^^^^^^^^^^^^^^^^ B006
@@ -238,7 +238,7 @@ B006_B008.py:110:45: B006 [*] Do not use mutable data structures for argument de
 112 114 | 
 113 115 | 
 
-B006_B008.py:114:33: B006 [*] Do not use mutable data structures for argument defaults
+B006_B008.py:114:33: B006 Do not use mutable data structures for argument defaults
     |
 114 | def kwonlyargs_mutable(*, value=[]):
     |                                 ^^ B006
@@ -258,7 +258,7 @@ B006_B008.py:114:33: B006 [*] Do not use mutable data structures for argument de
 116 118 | 
 117 119 | 
 
-B006_B008.py:239:20: B006 [*] Do not use mutable data structures for argument defaults
+B006_B008.py:239:20: B006 Do not use mutable data structures for argument defaults
     |
 237 | # B006 and B008
 238 | # We should handle arbitrary nesting of these B008.
@@ -280,7 +280,7 @@ B006_B008.py:239:20: B006 [*] Do not use mutable data structures for argument de
 241 243 | 
 242 244 | 
 
-B006_B008.py:276:27: B006 [*] Do not use mutable data structures for argument defaults
+B006_B008.py:276:27: B006 Do not use mutable data structures for argument defaults
     |
 275 | def mutable_annotations(
 276 |     a: list[int] | None = [],
@@ -306,7 +306,7 @@ B006_B008.py:276:27: B006 [*] Do not use mutable data structures for argument de
 282 284 | 
 283 285 | 
 
-B006_B008.py:277:35: B006 [*] Do not use mutable data structures for argument defaults
+B006_B008.py:277:35: B006 Do not use mutable data structures for argument defaults
     |
 275 | def mutable_annotations(
 276 |     a: list[int] | None = [],
@@ -332,7 +332,7 @@ B006_B008.py:277:35: B006 [*] Do not use mutable data structures for argument de
 282 284 | 
 283 285 | 
 
-B006_B008.py:278:62: B006 [*] Do not use mutable data structures for argument defaults
+B006_B008.py:278:62: B006 Do not use mutable data structures for argument defaults
     |
 276 |     a: list[int] | None = [],
 277 |     b: Optional[Dict[int, int]] = {},
@@ -357,7 +357,7 @@ B006_B008.py:278:62: B006 [*] Do not use mutable data structures for argument de
 282 284 | 
 283 285 | 
 
-B006_B008.py:279:80: B006 [*] Do not use mutable data structures for argument defaults
+B006_B008.py:279:80: B006 Do not use mutable data structures for argument defaults
     |
 277 |     b: Optional[Dict[int, int]] = {},
 278 |     c: Annotated[Union[Set[str], abc.Sized], "annotation"] = set(),
@@ -381,7 +381,7 @@ B006_B008.py:279:80: B006 [*] Do not use mutable data structures for argument de
 282 284 | 
 283 285 | 
 
-B006_B008.py:284:52: B006 [*] Do not use mutable data structures for argument defaults
+B006_B008.py:284:52: B006 Do not use mutable data structures for argument defaults
     |
 284 | def single_line_func_wrong(value: dict[str, str] = {}):
     |                                                    ^^ B006
@@ -402,7 +402,7 @@ B006_B008.py:284:52: B006 [*] Do not use mutable data structures for argument de
 287 289 | 
 288 290 | def single_line_func_wrong(value: dict[str, str] = {}):
 
-B006_B008.py:288:52: B006 [*] Do not use mutable data structures for argument defaults
+B006_B008.py:288:52: B006 Do not use mutable data structures for argument defaults
     |
 288 | def single_line_func_wrong(value: dict[str, str] = {}):
     |                                                    ^^ B006
@@ -424,7 +424,7 @@ B006_B008.py:288:52: B006 [*] Do not use mutable data structures for argument de
 291 293 | 
 292 294 | 
 
-B006_B008.py:293:52: B006 [*] Do not use mutable data structures for argument defaults
+B006_B008.py:293:52: B006 Do not use mutable data structures for argument defaults
     |
 293 | def single_line_func_wrong(value: dict[str, str] = {}):
     |                                                    ^^ B006
@@ -444,7 +444,7 @@ B006_B008.py:293:52: B006 [*] Do not use mutable data structures for argument de
 295 297 | 
 296 298 | 
 
-B006_B008.py:297:52: B006 [*] Do not use mutable data structures for argument defaults
+B006_B008.py:297:52: B006 Do not use mutable data structures for argument defaults
     |
 297 | def single_line_func_wrong(value: dict[str, str] = {}):
     |                                                    ^^ B006
@@ -465,7 +465,7 @@ B006_B008.py:297:52: B006 [*] Do not use mutable data structures for argument de
 299 301 |         ...
 300 302 | 
 
-B006_B008.py:302:52: B006 [*] Do not use mutable data structures for argument defaults
+B006_B008.py:302:52: B006 Do not use mutable data structures for argument defaults
     |
 302 |   def single_line_func_wrong(value: dict[str, str] = {
     |  ____________________________________________________^
@@ -500,7 +500,7 @@ B006_B008.py:308:52: B006 Do not use mutable data structures for argument defaul
     |
     = help: Replace with `None`; initialize within function
 
-B006_B008.py:313:52: B006 [*] Do not use mutable data structures for argument defaults
+B006_B008.py:313:52: B006 Do not use mutable data structures for argument defaults
     |
 313 | def single_line_func_wrong(value: dict[str, str] = {}):
     |                                                    ^^ B006

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

@@ -11,7 +11,7 @@ B009_B010.py:19:1: B009 [*] Do not call `getattr` with a constant attribute valu
    |
    = help: Replace `getattr` with attribute access
 
-ℹ Suggested fix
+ℹ Fix
 16 16 | getattr(foo, "__123abc")
 17 17 | 
 18 18 | # Invalid usage
@@ -32,7 +32,7 @@ B009_B010.py:20:1: B009 [*] Do not call `getattr` with a constant attribute valu
    |
    = help: Replace `getattr` with attribute access
 
-ℹ Suggested fix
+ℹ Fix
 17 17 | 
 18 18 | # Invalid usage
 19 19 | getattr(foo, "bar")
@@ -53,7 +53,7 @@ B009_B010.py:21:1: B009 [*] Do not call `getattr` with a constant attribute valu
    |
    = help: Replace `getattr` with attribute access
 
-ℹ Suggested fix
+ℹ Fix
 18 18 | # Invalid usage
 19 19 | getattr(foo, "bar")
 20 20 | getattr(foo, "_123abc")
@@ -74,7 +74,7 @@ B009_B010.py:22:1: B009 [*] Do not call `getattr` with a constant attribute valu
    |
    = help: Replace `getattr` with attribute access
 
-ℹ Suggested fix
+ℹ Fix
 19 19 | getattr(foo, "bar")
 20 20 | getattr(foo, "_123abc")
 21 21 | getattr(foo, "__123abc__")
@@ -95,7 +95,7 @@ B009_B010.py:23:1: B009 [*] Do not call `getattr` with a constant attribute valu
    |
    = help: Replace `getattr` with attribute access
 
-ℹ Suggested fix
+ℹ Fix
 20 20 | getattr(foo, "_123abc")
 21 21 | getattr(foo, "__123abc__")
 22 22 | getattr(foo, "abc123")
@@ -116,7 +116,7 @@ B009_B010.py:24:15: B009 [*] Do not call `getattr` with a constant attribute val
    |
    = help: Replace `getattr` with attribute access
 
-ℹ Suggested fix
+ℹ Fix
 21 21 | getattr(foo, "__123abc__")
 22 22 | getattr(foo, "abc123")
 23 23 | getattr(foo, r"abc123")
@@ -137,7 +137,7 @@ B009_B010.py:25:4: B009 [*] Do not call `getattr` with a constant attribute valu
    |
    = help: Replace `getattr` with attribute access
 
-ℹ Suggested fix
+ℹ Fix
 22 22 | getattr(foo, "abc123")
 23 23 | getattr(foo, r"abc123")
 24 24 | _ = lambda x: getattr(x, "bar")
@@ -158,7 +158,7 @@ B009_B010.py:27:1: B009 [*] Do not call `getattr` with a constant attribute valu
    |
    = help: Replace `getattr` with attribute access
 
-ℹ Suggested fix
+ℹ Fix
 24 24 | _ = lambda x: getattr(x, "bar")
 25 25 | if getattr(x, "bar"):
 26 26 |     pass
@@ -179,7 +179,7 @@ B009_B010.py:28:1: B009 [*] Do not call `getattr` with a constant attribute valu
    |
    = help: Replace `getattr` with attribute access
 
-ℹ Suggested fix
+ℹ Fix
 25 25 | if getattr(x, "bar"):
 26 26 |     pass
 27 27 | getattr(1, "real")
@@ -200,7 +200,7 @@ B009_B010.py:29:1: B009 [*] Do not call `getattr` with a constant attribute valu
    |
    = help: Replace `getattr` with attribute access
 
-ℹ Suggested fix
+ℹ Fix
 26 26 |     pass
 27 27 | getattr(1, "real")
 28 28 | getattr(1., "real")
@@ -221,7 +221,7 @@ B009_B010.py:30:1: B009 [*] Do not call `getattr` with a constant attribute valu
    |
    = help: Replace `getattr` with attribute access
 
-ℹ Suggested fix
+ℹ Fix
 27 27 | getattr(1, "real")
 28 28 | getattr(1., "real")
 29 29 | getattr(1.0, "real")
@@ -242,7 +242,7 @@ B009_B010.py:31:1: B009 [*] Do not call `getattr` with a constant attribute valu
    |
    = help: Replace `getattr` with attribute access
 
-ℹ Suggested fix
+ℹ Fix
 28 28 | getattr(1., "real")
 29 29 | getattr(1.0, "real")
 30 30 | getattr(1j, "real")
@@ -263,7 +263,7 @@ B009_B010.py:32:1: B009 [*] Do not call `getattr` with a constant attribute valu
    |
    = help: Replace `getattr` with attribute access
 
-ℹ Suggested fix
+ℹ Fix
 29 29 | getattr(1.0, "real")
 30 30 | getattr(1j, "real")
 31 31 | getattr(True, "real")
@@ -284,7 +284,7 @@ B009_B010.py:33:1: B009 [*] Do not call `getattr` with a constant attribute valu
    |
    = help: Replace `getattr` with attribute access
 
-ℹ Suggested fix
+ℹ Fix
 30 30 | getattr(1j, "real")
 31 31 | getattr(True, "real")
 32 32 | getattr(x := 1, "real")
@@ -304,7 +304,7 @@ B009_B010.py:34:1: B009 [*] Do not call `getattr` with a constant attribute valu
    |
    = help: Replace `getattr` with attribute access
 
-ℹ Suggested fix
+ℹ Fix
 31 31 | getattr(True, "real")
 32 32 | getattr(x := 1, "real")
 33 33 | getattr(x + y, "real")
@@ -326,7 +326,7 @@ B009_B010.py:58:8: B009 [*] Do not call `getattr` with a constant attribute valu
    |
    = help: Replace `getattr` with attribute access
 
-ℹ Suggested fix
+ℹ Fix
 55 55 | setattr(foo.bar, r"baz", None)
 56 56 | 
 57 57 | # Regression test for: https://github.com/astral-sh/ruff/issues/7455#issuecomment-1722458885
@@ -345,7 +345,7 @@ B009_B010.py:65:1: B009 [*] Do not call `getattr` with a constant attribute valu
    |
    = help: Replace `getattr` with attribute access
 
-ℹ Suggested fix
+ℹ Fix
 62 62 | setattr(*foo, "bar", None)
 63 63 | 
 64 64 | # Regression test for: https://github.com/astral-sh/ruff/issues/7455#issuecomment-1739800901