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

## Summary

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

## Test Plan

`cargo test`

CHANGELOG.md

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

Cargo.lock

@@ -2038,7 +2038,7 @@ dependencies = [
 
 [[package]]
 name = "ruff_cli"
-version = "0.1.11"
+version = "0.1.13"
 dependencies = [
  "anyhow",
  "argfile",
@@ -2165,7 +2165,7 @@ dependencies = [
 
 [[package]]
 name = "ruff_linter"
-version = "0.1.11"
+version = "0.1.13"
 dependencies = [
  "aho-corasick",
  "annotate-snippets 0.9.2",
@@ -2417,7 +2417,7 @@ dependencies = [
 
 [[package]]
 name = "ruff_shrinking"
-version = "0.1.11"
+version = "0.1.13"
 dependencies = [
  "anyhow",
  "clap",

README.md

@@ -150,7 +150,7 @@ Ruff can also be used as a [pre-commit](https://pre-commit.com/) hook via [`ruff
 ```yaml
 - repo: https://github.com/astral-sh/ruff-pre-commit
   # Ruff version.
-  rev: v0.1.11
+  rev: v0.1.13
   hooks:
     # Run the linter.
     - id: ruff

crates/ruff_cli/Cargo.toml

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

crates/ruff_cli/src/args.rs

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

crates/ruff_cli/src/commands/format.rs

@@ -106,13 +106,19 @@ pub(crate) fn format(
             match entry {
                 Ok(resolved_file) => {
                     let path = resolved_file.path();
-                    let SourceType::Python(source_type) = SourceType::from(&path) else {
-                        // Ignore any non-Python files.
-                        return None;
-                    };
-
                     let settings = resolver.resolve(path);
 
+                    let source_type = match settings.formatter.extension.get(path) {
+                        None => match SourceType::from(path) {
+                            SourceType::Python(source_type) => source_type,
+                            SourceType::Toml(_) => {
+                                // Ignore any non-Python files.
+                                return None;
+                            }
+                        },
+                        Some(language) => PySourceType::from(language),
+                    };
+
                     // Ignore files that are excluded from formatting
                     if (settings.file_resolver.force_exclude || !resolved_file.is_root())
                         && match_exclusion(

crates/ruff_cli/src/commands/format_stdin.rs

@@ -53,16 +53,23 @@ pub(crate) fn format_stdin(cli: &FormatArguments, overrides: &CliOverrides) -> R
     }
 
     let path = cli.stdin_filename.as_deref();
+    let settings = &resolver.base_settings().formatter;
 
-    let SourceType::Python(source_type) = path.map(SourceType::from).unwrap_or_default() else {
-        if mode.is_write() {
-            parrot_stdin()?;
-        }
-        return Ok(ExitStatus::Success);
+    let source_type = match path.and_then(|path| settings.extension.get(path)) {
+        None => match path.map(SourceType::from).unwrap_or_default() {
+            SourceType::Python(source_type) => source_type,
+            SourceType::Toml(_) => {
+                if mode.is_write() {
+                    parrot_stdin()?;
+                }
+                return Ok(ExitStatus::Success);
+            }
+        },
+        Some(language) => PySourceType::from(language),
     };
 
     // Format the file.
-    match format_source_code(path, &resolver.base_settings().formatter, source_type, mode) {
+    match format_source_code(path, settings, source_type, mode) {
         Ok(result) => match mode {
             FormatMode::Write => Ok(ExitStatus::Success),
             FormatMode::Check | FormatMode::Diff => {

crates/ruff_cli/src/commands/show_settings.rs

@@ -35,7 +35,7 @@ pub(crate) fn show_settings(
     if let Some(settings_path) = pyproject_config.path.as_ref() {
         writeln!(writer, "Settings path: {settings_path:?}")?;
     }
-    writeln!(writer, "{settings:#?}")?;
+    write!(writer, "{settings}")?;
 
     Ok(())
 }

crates/ruff_cli/src/diagnostics.rs

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

crates/ruff_cli/tests/format.rs

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

crates/ruff_cli/tests/lint.rs

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

crates/ruff_cli/tests/show_settings.rs

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

crates/ruff_cli/tests/snapshots/show_settings__display_default_settings.snap

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

crates/ruff_formatter/src/lib.rs

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

crates/ruff_linter/Cargo.toml

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -863,6 +863,9 @@ pub(crate) fn expression(expr: &Expr, checker: &mut Checker) {
             if checker.enabled(Rule::DictGetWithNoneDefault) {
                 flake8_simplify::rules::dict_get_with_none_default(checker, expr);
             }
+            if checker.enabled(Rule::ZipDictKeysAndValues) {
+                flake8_simplify::rules::zip_dict_keys_and_values(checker, call);
+            }
             if checker.any_enabled(&[
                 Rule::OsPathAbspath,
                 Rule::OsChmod,
@@ -977,9 +980,9 @@ pub(crate) fn expression(expr: &Expr, checker: &mut Checker) {
                 flake8_pie::rules::unnecessary_spread(checker, dict);
             }
         }
-        Expr::Set(ast::ExprSet { elts, range: _ }) => {
+        Expr::Set(set) => {
             if checker.enabled(Rule::DuplicateValue) {
-                flake8_bugbear::rules::duplicate_value(checker, elts);
+                flake8_bugbear::rules::duplicate_value(checker, set);
             }
         }
         Expr::Yield(_) => {

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

@@ -355,12 +355,6 @@ pub(crate) fn statement(stmt: &Stmt, checker: &mut Checker) {
             if checker.enabled(Rule::TrioAsyncFunctionWithTimeout) {
                 flake8_trio::rules::async_function_with_timeout(checker, function_def);
             }
-            #[cfg(feature = "unreachable-code")]
-            if checker.enabled(Rule::UnreachableCode) {
-                checker
-                    .diagnostics
-                    .extend(ruff::rules::unreachable::in_function(name, body));
-            }
             if checker.enabled(Rule::ReimplementedOperator) {
                 refurb::rules::reimplemented_operator(checker, &function_def.into());
             }
@@ -1264,9 +1258,10 @@ pub(crate) fn statement(stmt: &Stmt, checker: &mut Checker) {
             },
         ) => {
             if checker.any_enabled(&[
-                Rule::UnusedLoopControlVariable,
+                Rule::EnumerateForLoop,
                 Rule::IncorrectDictIterator,
                 Rule::UnnecessaryEnumerate,
+                Rule::UnusedLoopControlVariable,
                 Rule::YieldInForLoop,
             ]) {
                 checker.deferred.for_loops.push(checker.semantic.snapshot());

crates/ruff_linter/src/checkers/logical_lines.rs

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

crates/ruff_linter/src/codes.rs

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

crates/ruff_linter/src/line_width.rs

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

crates/ruff_linter/src/registry/rule_set.rs

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

crates/ruff_linter/src/rule_selector.rs

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -287,7 +287,7 @@ impl AlwaysFixableViolation for ExprAndFalse {
 }
 
 /// Return `true` if two `Expr` instances are equivalent names.
-fn is_same_expr<'a>(a: &'a Expr, b: &'a Expr) -> Option<&'a str> {
+pub(crate) fn is_same_expr<'a>(a: &'a Expr, b: &'a Expr) -> Option<&'a str> {
     if let (Expr::Name(ast::ExprName { id: a, .. }), Expr::Name(ast::ExprName { id: b, .. })) =
         (&a, &b)
     {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

crates/ruff_linter/src/rules/pandas_vet/rules/inplace_argument.rs

@@ -61,6 +61,15 @@ pub(crate) fn inplace_argument(checker: &mut Checker, call: &ast::ExprCall) {
         return;
     }
 
+    // If the function doesn't take an `inplace` argument, abort.
+    if !call
+        .func
+        .as_attribute_expr()
+        .is_some_and(|func| accepts_inplace_argument(&func.attr))
+    {
+        return;
+    }
+
     let mut seen_star = false;
     for keyword in call.arguments.keywords.iter().rev() {
         let Some(arg) = &keyword.arg else {
@@ -134,3 +143,35 @@ fn convert_inplace_argument_to_assignment(
 
     Some(Fix::unsafe_edits(insert_assignment, [remove_argument]))
 }
+
+/// Returns `true` if the given method accepts an `inplace` argument when used on a Pandas
+/// `DataFrame`, `Series`, or `Index`.
+///
+/// See: <https://pandas.pydata.org/docs/reference/frame.html>
+fn accepts_inplace_argument(method: &str) -> bool {
+    matches!(
+        method,
+        "where"
+            | "mask"
+            | "query"
+            | "clip"
+            | "eval"
+            | "backfill"
+            | "bfill"
+            | "ffill"
+            | "fillna"
+            | "interpolate"
+            | "dropna"
+            | "pad"
+            | "replace"
+            | "drop"
+            | "drop_duplicates"
+            | "rename"
+            | "rename_axis"
+            | "reset_index"
+            | "set_index"
+            | "sort_values"
+            | "sort_index"
+            | "set_names"
+    )
+}

crates/ruff_linter/src/rules/pandas_vet/snapshots/ruff_linter__rules__pandas_vet__tests__PD002_PD002.py.snap

@@ -164,6 +164,8 @@ PD002.py:33:24: PD002 [*] `inplace=True` should be avoided; it has inconsistent
 32 | 
 33 | (x.drop(["a"], axis=1, inplace=True))
    |                        ^^^^^^^^^^^^ PD002
+34 | 
+35 | # This method doesn't take exist in Pandas, so ignore it.
    |
    = help: Assign to variable; remove `inplace` arg
 
@@ -173,5 +175,8 @@ PD002.py:33:24: PD002 [*] `inplace=True` should be avoided; it has inconsistent
 32 32 | 
 33    |-(x.drop(["a"], axis=1, inplace=True))
    33 |+x = (x.drop(["a"], axis=1))
+34 34 | 
+35 35 | # This method doesn't take exist in Pandas, so ignore it.
+36 36 | x.rotate_z(45, inplace=True)
 
 

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

@@ -2,7 +2,9 @@
 
 use std::error::Error;
 use std::fmt;
+use std::fmt::Formatter;
 
+use crate::display_settings;
 use ruff_macros::CacheKey;
 
 use crate::settings::types::IdentifierPattern;
@@ -44,6 +46,21 @@ impl Default for Settings {
     }
 }
 
+impl fmt::Display for Settings {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        display_settings! {
+            formatter = f,
+            namespace = "linter.pep8_naming",
+            fields = [
+                self.ignore_names | array,
+                self.classmethod_decorators | array,
+                self.staticmethod_decorators | array
+            ]
+        }
+        Ok(())
+    }
+}
+
 /// Error returned by the [`TryFrom`] implementation of [`Settings`].
 #[derive(Debug)]
 pub enum SettingsError {

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

@@ -1,6 +1,8 @@
 //! Settings for the `pycodestyle` plugin.
 
+use crate::display_settings;
 use ruff_macros::CacheKey;
+use std::fmt;
 
 use crate::line_width::LineLength;
 
@@ -10,3 +12,18 @@ pub struct Settings {
     pub max_doc_length: Option<LineLength>,
     pub ignore_overlong_task_comments: bool,
 }
+
+impl fmt::Display for Settings {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        display_settings! {
+            formatter = f,
+            namespace = "linter.pycodestyle",
+            fields = [
+                self.max_line_length,
+                self.max_doc_length | optional,
+                self.ignore_overlong_task_comments,
+            ]
+        }
+        Ok(())
+    }
+}

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

@@ -1,9 +1,11 @@
 //! Settings for the `pydocstyle` plugin.
 
 use std::collections::BTreeSet;
+use std::fmt;
 
 use serde::{Deserialize, Serialize};
 
+use crate::display_settings;
 use ruff_macros::CacheKey;
 
 use crate::registry::Rule;
@@ -71,9 +73,34 @@ impl Convention {
     }
 }
 
+impl fmt::Display for Convention {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::Google => write!(f, "google"),
+            Self::Numpy => write!(f, "numpy"),
+            Self::Pep257 => write!(f, "pep257"),
+        }
+    }
+}
+
 #[derive(Debug, Default, CacheKey)]
 pub struct Settings {
     pub convention: Option<Convention>,
     pub ignore_decorators: BTreeSet<String>,
     pub property_decorators: BTreeSet<String>,
 }
+
+impl fmt::Display for Settings {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        display_settings! {
+            formatter = f,
+            namespace = "linter.pydocstyle",
+            fields = [
+                self.convention | optional,
+                self.ignore_decorators | debug,
+                self.property_decorators | debug
+            ]
+        }
+        Ok(())
+    }
+}

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

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

crates/ruff_linter/src/rules/pylint/rules/unnecessary_dunder_call.rs

@@ -1,6 +1,6 @@
 use ruff_diagnostics::{Diagnostic, Edit, Fix, FixAvailability, Violation};
 use ruff_macros::{derive_message_formats, violation};
-use ruff_python_ast::{self as ast, Expr};
+use ruff_python_ast::{self as ast, Expr, Stmt};
 use ruff_python_semantic::SemanticModel;
 use ruff_text_size::Ranged;
 
@@ -80,11 +80,17 @@ pub(crate) fn unnecessary_dunder_call(checker: &mut Checker, call: &ast::ExprCal
         return;
     }
 
-    // Ignore certain dunder methods used in lambda expressions.
+    // Ignore certain dunder method calls in lambda expressions. These methods would require
+    // rewriting as a statement, which is not possible in a lambda expression.
     if allow_nested_expression(attr, checker.semantic()) {
         return;
     }
 
+    // Ignore dunder method calls within dunder methods definitions.
+    if in_dunder_method_definition(checker.semantic()) {
+        return;
+    }
+
     // Ignore dunder methods used on `super`.
     if let Expr::Call(ast::ExprCall { func, .. }) = value.as_ref() {
         if checker.semantic().is_builtin("super") {
@@ -273,7 +279,7 @@ impl DunderReplacement {
             "__str__" => Some(Self::Builtin("str", "Use `str()` builtin")),
             "__subclasscheck__" => Some(Self::Builtin("issubclass", "Use `issubclass()` builtin")),
 
-            "__aenter__" => Some(Self::MessageOnly("Use `aenter()` builtin")),
+            "__aenter__" => Some(Self::MessageOnly("Invoke context manager directly")),
             "__ceil__" => Some(Self::MessageOnly("Use `math.ceil()` function")),
             "__copy__" => Some(Self::MessageOnly("Use `copy.copy()` function")),
             "__deepcopy__" => Some(Self::MessageOnly("Use `copy.deepcopy()` function")),
@@ -283,15 +289,15 @@ impl DunderReplacement {
             "__delitem__" => Some(Self::MessageOnly("Use `del` statement")),
             "__divmod__" => Some(Self::MessageOnly("Use `divmod()` builtin")),
             "__format__" => Some(Self::MessageOnly(
-                "Use `format` builtin, format string method, or f-string.",
+                "Use `format` builtin, format string method, or f-string",
             )),
             "__fspath__" => Some(Self::MessageOnly("Use `os.fspath` function")),
             "__get__" => Some(Self::MessageOnly("Use `get` method")),
             "__getattr__" => Some(Self::MessageOnly(
-                "Access attribute directly or use getattr built-in function.",
+                "Access attribute directly or use getattr built-in function",
             )),
             "__getattribute__" => Some(Self::MessageOnly(
-                "Access attribute directly or use getattr built-in function.",
+                "Access attribute directly or use getattr built-in function",
             )),
             "__getitem__" => Some(Self::MessageOnly("Access item via subscript")),
             "__init__" => Some(Self::MessageOnly("Instantiate class directly")),
@@ -304,7 +310,7 @@ impl DunderReplacement {
             "__rpow__" => Some(Self::MessageOnly("Use ** operator or `pow()` builtin")),
             "__set__" => Some(Self::MessageOnly("Use subscript assignment")),
             "__setattr__" => Some(Self::MessageOnly(
-                "Mutate attribute directly or use setattr built-in function.",
+                "Mutate attribute directly or use setattr built-in function",
             )),
             "__setitem__" => Some(Self::MessageOnly("Use subscript assignment")),
             "__truncate__" => Some(Self::MessageOnly("Use `math.trunc()` function")),
@@ -344,3 +350,13 @@ fn allow_nested_expression(dunder_name: &str, semantic: &SemanticModel) -> bool
                 | "__ior__"
         )
 }
+
+/// Returns `true` if the [`SemanticModel`] is currently in a dunder method definition.
+fn in_dunder_method_definition(semantic: &SemanticModel) -> bool {
+    semantic.current_statements().any(|statement| {
+        let Stmt::FunctionDef(func_def) = statement else {
+            return false;
+        };
+        func_def.name.starts_with("__") && func_def.name.ends_with("__")
+    })
+}

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

@@ -2,7 +2,9 @@
 
 use rustc_hash::FxHashSet;
 use serde::{Deserialize, Serialize};
+use std::fmt;
 
+use crate::display_settings;
 use ruff_macros::CacheKey;
 use ruff_python_ast::{ExprNumberLiteral, LiteralExpressionRef, Number};
 
@@ -34,6 +36,18 @@ impl ConstantType {
     }
 }
 
+impl fmt::Display for ConstantType {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::Bytes => write!(f, "bytes"),
+            Self::Complex => write!(f, "complex"),
+            Self::Float => write!(f, "float"),
+            Self::Int => write!(f, "int"),
+            Self::Str => write!(f, "str"),
+        }
+    }
+}
+
 #[derive(Debug, CacheKey)]
 pub struct Settings {
     pub allow_magic_value_types: Vec<ConstantType>,
@@ -64,3 +78,25 @@ impl Default for Settings {
         }
     }
 }
+
+impl fmt::Display for Settings {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        display_settings! {
+            formatter = f,
+            namespace = "linter.pylint",
+            fields = [
+                self.allow_magic_value_types | array,
+                self.allow_dunder_method_names | array,
+                self.max_args,
+                self.max_positional_args,
+                self.max_returns,
+                self.max_bool_expr,
+                self.max_branches,
+                self.max_statements,
+                self.max_public_methods,
+                self.max_locals
+            ]
+        }
+        Ok(())
+    }
+}

crates/ruff_linter/src/rules/pylint/snapshots/ruff_linter__rules__pylint__tests__PLC2801_unnecessary_dunder_call.py.snap

@@ -321,4 +321,12 @@ unnecessary_dunder_call.py:19:7: PLC2801 Unnecessary dunder call to `__neg__`. M
    |
    = help: Multiply by -1 instead
 
+unnecessary_dunder_call.py:31:16: PLC2801 Unnecessary dunder call to `__getattribute__`. Access attribute directly or use getattr built-in function.
+   |
+30 |     def do_thing(self, item):
+31 |         return object.__getattribute__(self, item)  # PLC2801
+   |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ PLC2801
+   |
+   = help: Access attribute directly or use getattr built-in function
+
 

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

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

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

@@ -16,8 +16,7 @@ mod tests {
 
     use crate::pyproject_toml::lint_pyproject_toml;
     use crate::registry::Rule;
-    use crate::settings::resolve_per_file_ignores;
-    use crate::settings::types::{PerFileIgnore, PreviewMode, PythonVersion};
+    use crate::settings::types::{PerFileIgnore, PerFileIgnores, PreviewMode, PythonVersion};
     use crate::test::{test_path, test_resource_path};
     use crate::{assert_messages, settings};
 
@@ -37,10 +36,6 @@ mod tests {
         Path::new("RUF015.py")
     )]
     #[test_case(Rule::InvalidIndexType, Path::new("RUF016.py"))]
-    #[cfg_attr(
-        feature = "unreachable-code",
-        test_case(Rule::UnreachableCode, Path::new("RUF014.py"))
-    )]
     #[test_case(Rule::QuadraticListSummation, Path::new("RUF017_1.py"))]
     #[test_case(Rule::QuadraticListSummation, Path::new("RUF017_0.py"))]
     #[test_case(Rule::AssignmentInAssert, Path::new("RUF018.py"))]
@@ -175,7 +170,7 @@ mod tests {
         let mut settings =
             settings::LinterSettings::for_rules(vec![Rule::UnusedNOQA, Rule::UnusedImport]);
 
-        settings.per_file_ignores = resolve_per_file_ignores(vec![PerFileIgnore::new(
+        settings.per_file_ignores = PerFileIgnores::resolve(vec![PerFileIgnore::new(
             "RUF100_2.py".to_string(),
             &["F401".parse().unwrap()],
             None,
@@ -232,7 +227,7 @@ mod tests {
         let diagnostics = test_path(
             Path::new("ruff/ruff_per_file_ignores.py"),
             &settings::LinterSettings {
-                per_file_ignores: resolve_per_file_ignores(vec![PerFileIgnore::new(
+                per_file_ignores: PerFileIgnores::resolve(vec![PerFileIgnore::new(
                     "ruff_per_file_ignores.py".to_string(),
                     &["F401".parse().unwrap(), "RUF100".parse().unwrap()],
                     None,

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

@@ -16,8 +16,6 @@ pub(crate) use quadratic_list_summation::*;
 pub(crate) use static_key_dict_comprehension::*;
 pub(crate) use unnecessary_iterable_allocation_for_first_element::*;
 pub(crate) use unnecessary_key_check::*;
-#[cfg(feature = "unreachable-code")]
-pub(crate) use unreachable::*;
 pub(crate) use unused_noqa::*;
 
 mod ambiguous_unicode_character;
@@ -39,8 +37,6 @@ mod parenthesize_logical_operators;
 mod static_key_dict_comprehension;
 mod unnecessary_iterable_allocation_for_first_element;
 mod unnecessary_key_check;
-#[cfg(feature = "unreachable-code")]
-pub(crate) mod unreachable;
 mod unused_noqa;
 
 #[derive(Clone, Copy)]

crates/ruff_linter/src/rules/ruff/rules/parenthesize_logical_operators.rs

@@ -32,7 +32,7 @@ use crate::checkers::ast::Checker;
 ///
 /// d, e, f = 0, 1, 2
 /// y = (d and e) or f
-/// ````
+/// ```
 #[violation]
 pub struct ParenthesizeChainedOperators;
 

crates/ruff_linter/src/rules/ruff/rules/snapshots/ruff_linter__rules__ruff__rules__unreachable__tests__assert.py.md.snap

@@ -1,97 +0,0 @@
----
-source: crates/ruff_linter/src/rules/ruff/rules/unreachable.rs
-description: "This is a Mermaid graph. You can use https://mermaid.live to visualize it as a diagram."
----
-## Function 0
-### Source
-```python
-def func():
-    assert True
-```
-
-### Control Flow Graph
-```mermaid
-flowchart TD
-  start(("Start"))
-  return(("End"))
-  block0[["`*(empty)*`"]]
-  block1[["Exception raised"]]
-  block2["assert True\n"]
-
-  start --> block2
-  block2 -- "True" --> block0
-  block2 -- "else" --> block1
-  block1 --> return
-  block0 --> return
-```
-
-## Function 1
-### Source
-```python
-def func():
-    assert False
-```
-
-### Control Flow Graph
-```mermaid
-flowchart TD
-  start(("Start"))
-  return(("End"))
-  block0[["`*(empty)*`"]]
-  block1[["Exception raised"]]
-  block2["assert False\n"]
-
-  start --> block2
-  block2 -- "False" --> block0
-  block2 -- "else" --> block1
-  block1 --> return
-  block0 --> return
-```
-
-## Function 2
-### Source
-```python
-def func():
-    assert True, "oops"
-```
-
-### Control Flow Graph
-```mermaid
-flowchart TD
-  start(("Start"))
-  return(("End"))
-  block0[["`*(empty)*`"]]
-  block1[["Exception raised"]]
-  block2["assert True, #quot;oops#quot;\n"]
-
-  start --> block2
-  block2 -- "True" --> block0
-  block2 -- "else" --> block1
-  block1 --> return
-  block0 --> return
-```
-
-## Function 3
-### Source
-```python
-def func():
-    assert False, "oops"
-```
-
-### Control Flow Graph
-```mermaid
-flowchart TD
-  start(("Start"))
-  return(("End"))
-  block0[["`*(empty)*`"]]
-  block1[["Exception raised"]]
-  block2["assert False, #quot;oops#quot;\n"]
-
-  start --> block2
-  block2 -- "False" --> block0
-  block2 -- "else" --> block1
-  block1 --> return
-  block0 --> return
-```
-
-

crates/ruff_linter/src/rules/ruff/rules/snapshots/ruff_linter__rules__ruff__rules__unreachable__tests__async-for.py.md.snap

@@ -1,241 +0,0 @@
----
-source: crates/ruff_linter/src/rules/ruff/rules/unreachable.rs
-description: "This is a Mermaid graph. You can use https://mermaid.live to visualize it as a diagram."
----
-## Function 0
-### Source
-```python
-def func():
-    async for i in range(5):
-        print(i)
-```
-
-### Control Flow Graph
-```mermaid
-flowchart TD
-  start(("Start"))
-  return(("End"))
-  block0[["`*(empty)*`"]]
-  block1["print(i)\n"]
-  block2["async for i in range(5):
-        print(i)\n"]
-
-  start --> block2
-  block2 -- "range(5)" --> block1
-  block2 -- "else" --> block0
-  block1 --> block2
-  block0 --> return
-```
-
-## Function 1
-### Source
-```python
-def func():
-    async for i in range(20):
-        print(i)
-    else:
-        return 0
-```
-
-### Control Flow Graph
-```mermaid
-flowchart TD
-  start(("Start"))
-  return(("End"))
-  block0["print(i)\n"]
-  block1["return 0\n"]
-  block2["async for i in range(20):
-        print(i)
-    else:
-        return 0\n"]
-
-  start --> block2
-  block2 -- "range(20)" --> block0
-  block2 -- "else" --> block1
-  block1 --> return
-  block0 --> return
-```
-
-## Function 2
-### Source
-```python
-def func():
-    async for i in range(10):
-        if i == 5:
-            return 1
-    return 0
-```
-
-### Control Flow Graph
-```mermaid
-flowchart TD
-  start(("Start"))
-  return(("End"))
-  block0["return 0\n"]
-  block1["return 1\n"]
-  block2["if i == 5:
-            return 1\n"]
-  block3["async for i in range(10):
-        if i == 5:
-            return 1\n"]
-
-  start --> block3
-  block3 -- "range(10)" --> block2
-  block3 -- "else" --> block0
-  block2 -- "i == 5" --> block1
-  block2 -- "else" --> block3
-  block1 --> return
-  block0 --> return
-```
-
-## Function 3
-### Source
-```python
-def func():
-    async for i in range(111):
-        if i == 5:
-            return 1
-    else:
-        return 0
-    return 2
-```
-
-### Control Flow Graph
-```mermaid
-flowchart TD
-  start(("Start"))
-  return(("End"))
-  block0["return 2\n"]
-  block1["return 1\n"]
-  block2["if i == 5:
-            return 1\n"]
-  block3["return 0\n"]
-  block4["async for i in range(111):
-        if i == 5:
-            return 1
-    else:
-        return 0\n"]
-
-  start --> block4
-  block4 -- "range(111)" --> block2
-  block4 -- "else" --> block3
-  block3 --> return
-  block2 -- "i == 5" --> block1
-  block2 -- "else" --> block4
-  block1 --> return
-  block0 --> return
-```
-
-## Function 4
-### Source
-```python
-def func():
-    async for i in range(12):
-        continue
-```
-
-### Control Flow Graph
-```mermaid
-flowchart TD
-  start(("Start"))
-  return(("End"))
-  block0[["`*(empty)*`"]]
-  block1["continue\n"]
-  block2["async for i in range(12):
-        continue\n"]
-
-  start --> block2
-  block2 -- "range(12)" --> block1
-  block2 -- "else" --> block0
-  block1 --> block2
-  block0 --> return
-```
-
-## Function 5
-### Source
-```python
-def func():
-    async for i in range(1110):
-        if True:
-            continue
-```
-
-### Control Flow Graph
-```mermaid
-flowchart TD
-  start(("Start"))
-  return(("End"))
-  block0[["`*(empty)*`"]]
-  block1["continue\n"]
-  block2["if True:
-            continue\n"]
-  block3["async for i in range(1110):
-        if True:
-            continue\n"]
-
-  start --> block3
-  block3 -- "range(1110)" --> block2
-  block3 -- "else" --> block0
-  block2 -- "True" --> block1
-  block2 -- "else" --> block3
-  block1 --> block3
-  block0 --> return
-```
-
-## Function 6
-### Source
-```python
-def func():
-    async for i in range(13):
-        break
-```
-
-### Control Flow Graph
-```mermaid
-flowchart TD
-  start(("Start"))
-  return(("End"))
-  block0[["`*(empty)*`"]]
-  block1["break\n"]
-  block2["async for i in range(13):
-        break\n"]
-
-  start --> block2
-  block2 -- "range(13)" --> block1
-  block2 -- "else" --> block0
-  block1 --> block0
-  block0 --> return
-```
-
-## Function 7
-### Source
-```python
-def func():
-    async for i in range(1110):
-        if True:
-            break
-```
-
-### Control Flow Graph
-```mermaid
-flowchart TD
-  start(("Start"))
-  return(("End"))
-  block0[["`*(empty)*`"]]
-  block1["break\n"]
-  block2["if True:
-            break\n"]
-  block3["async for i in range(1110):
-        if True:
-            break\n"]
-
-  start --> block3
-  block3 -- "range(1110)" --> block2
-  block3 -- "else" --> block0
-  block2 -- "True" --> block1
-  block2 -- "else" --> block3
-  block1 --> block0
-  block0 --> return
-```
-
-

crates/ruff_linter/src/rules/ruff/rules/snapshots/ruff_linter__rules__ruff__rules__unreachable__tests__for.py.md.snap

@@ -1,302 +0,0 @@
----
-source: crates/ruff_linter/src/rules/ruff/rules/unreachable.rs
-description: "This is a Mermaid graph. You can use https://mermaid.live to visualize it as a diagram."
----
-## Function 0
-### Source
-```python
-def func():
-    for i in range(5):
-        print(i)
-```
-
-### Control Flow Graph
-```mermaid
-flowchart TD
-  start(("Start"))
-  return(("End"))
-  block0[["`*(empty)*`"]]
-  block1["print(i)\n"]
-  block2["for i in range(5):
-        print(i)\n"]
-
-  start --> block2
-  block2 -- "range(5)" --> block1
-  block2 -- "else" --> block0
-  block1 --> block2
-  block0 --> return
-```
-
-## Function 1
-### Source
-```python
-def func():
-    for i in range(20):
-        print(i)
-    else:
-        return 0
-```
-
-### Control Flow Graph
-```mermaid
-flowchart TD
-  start(("Start"))
-  return(("End"))
-  block0["print(i)\n"]
-  block1["return 0\n"]
-  block2["for i in range(20):
-        print(i)
-    else:
-        return 0\n"]
-
-  start --> block2
-  block2 -- "range(20)" --> block0
-  block2 -- "else" --> block1
-  block1 --> return
-  block0 --> return
-```
-
-## Function 2
-### Source
-```python
-def func():
-    for i in range(10):
-        if i == 5:
-            return 1
-    return 0
-```
-
-### Control Flow Graph
-```mermaid
-flowchart TD
-  start(("Start"))
-  return(("End"))
-  block0["return 0\n"]
-  block1["return 1\n"]
-  block2["if i == 5:
-            return 1\n"]
-  block3["for i in range(10):
-        if i == 5:
-            return 1\n"]
-
-  start --> block3
-  block3 -- "range(10)" --> block2
-  block3 -- "else" --> block0
-  block2 -- "i == 5" --> block1
-  block2 -- "else" --> block3
-  block1 --> return
-  block0 --> return
-```
-
-## Function 3
-### Source
-```python
-def func():
-    for i in range(111):
-        if i == 5:
-            return 1
-    else:
-        return 0
-    return 2
-```
-
-### Control Flow Graph
-```mermaid
-flowchart TD
-  start(("Start"))
-  return(("End"))
-  block0["return 2\n"]
-  block1["return 1\n"]
-  block2["if i == 5:
-            return 1\n"]
-  block3["return 0\n"]
-  block4["for i in range(111):
-        if i == 5:
-            return 1
-    else:
-        return 0\n"]
-
-  start --> block4
-  block4 -- "range(111)" --> block2
-  block4 -- "else" --> block3
-  block3 --> return
-  block2 -- "i == 5" --> block1
-  block2 -- "else" --> block4
-  block1 --> return
-  block0 --> return
-```
-
-## Function 4
-### Source
-```python
-def func():
-    for i in range(12):
-        continue
-```
-
-### Control Flow Graph
-```mermaid
-flowchart TD
-  start(("Start"))
-  return(("End"))
-  block0[["`*(empty)*`"]]
-  block1["continue\n"]
-  block2["for i in range(12):
-        continue\n"]
-
-  start --> block2
-  block2 -- "range(12)" --> block1
-  block2 -- "else" --> block0
-  block1 --> block2
-  block0 --> return
-```
-
-## Function 5
-### Source
-```python
-def func():
-    for i in range(1110):
-        if True:
-            continue
-```
-
-### Control Flow Graph
-```mermaid
-flowchart TD
-  start(("Start"))
-  return(("End"))
-  block0[["`*(empty)*`"]]
-  block1["continue\n"]
-  block2["if True:
-            continue\n"]
-  block3["for i in range(1110):
-        if True:
-            continue\n"]
-
-  start --> block3
-  block3 -- "range(1110)" --> block2
-  block3 -- "else" --> block0
-  block2 -- "True" --> block1
-  block2 -- "else" --> block3
-  block1 --> block3
-  block0 --> return
-```
-
-## Function 6
-### Source
-```python
-def func():
-    for i in range(13):
-        break
-```
-
-### Control Flow Graph
-```mermaid
-flowchart TD
-  start(("Start"))
-  return(("End"))
-  block0[["`*(empty)*`"]]
-  block1["break\n"]
-  block2["for i in range(13):
-        break\n"]
-
-  start --> block2
-  block2 -- "range(13)" --> block1
-  block2 -- "else" --> block0
-  block1 --> block0
-  block0 --> return
-```
-
-## Function 7
-### Source
-```python
-def func():
-    for i in range(1110):
-        if True:
-            break
-```
-
-### Control Flow Graph
-```mermaid
-flowchart TD
-  start(("Start"))
-  return(("End"))
-  block0[["`*(empty)*`"]]
-  block1["break\n"]
-  block2["if True:
-            break\n"]
-  block3["for i in range(1110):
-        if True:
-            break\n"]
-
-  start --> block3
-  block3 -- "range(1110)" --> block2
-  block3 -- "else" --> block0
-  block2 -- "True" --> block1
-  block2 -- "else" --> block3
-  block1 --> block0
-  block0 --> return
-```
-
-## Function 8
-### Source
-```python
-def func():
-    for i in range(5):
-        pass
-    else:
-        return 1
-```
-
-### Control Flow Graph
-```mermaid
-flowchart TD
-  start(("Start"))
-  return(("End"))
-  block0["pass\n"]
-  block1["return 1\n"]
-  block2["for i in range(5):
-        pass
-    else:
-        return 1\n"]
-
-  start --> block2
-  block2 -- "range(5)" --> block0
-  block2 -- "else" --> block1
-  block1 --> return
-  block0 --> return
-```
-
-## Function 9
-### Source
-```python
-def func():
-    for i in range(5):
-        pass
-    else:
-        return 1
-    x = 1
-```
-
-### Control Flow Graph
-```mermaid
-flowchart TD
-  start(("Start"))
-  return(("End"))
-  block0["x = 1\n"]
-  block1["pass\n"]
-  block2["return 1\n"]
-  block3["for i in range(5):
-        pass
-    else:
-        return 1\n"]
-
-  start --> block3
-  block3 -- "range(5)" --> block1
-  block3 -- "else" --> block2
-  block2 --> return
-  block1 --> block3
-  block0 --> return
-```
-
-

crates/ruff_linter/src/rules/ruff/rules/snapshots/ruff_linter__rules__ruff__rules__unreachable__tests__if.py.md.snap

@@ -1,553 +0,0 @@
----
-source: crates/ruff_linter/src/rules/ruff/rules/unreachable.rs
-description: "This is a Mermaid graph. You can use https://mermaid.live to visualize it as a diagram."
----
-## Function 0
-### Source
-```python
-def func():
-    if False:
-        return 0
-    return 1
-```
-
-### Control Flow Graph
-```mermaid
-flowchart TD
-  start(("Start"))
-  return(("End"))
-  block0["return 1\n"]
-  block1["return 0\n"]
-  block2["if False:
-        return 0\n"]
-
-  start --> block2
-  block2 -- "False" --> block1
-  block2 -- "else" --> block0
-  block1 --> return
-  block0 --> return
-```
-
-## Function 1
-### Source
-```python
-def func():
-    if True:
-        return 1
-    return 0
-```
-
-### Control Flow Graph
-```mermaid
-flowchart TD
-  start(("Start"))
-  return(("End"))
-  block0["return 0\n"]
-  block1["return 1\n"]
-  block2["if True:
-        return 1\n"]
-
-  start --> block2
-  block2 -- "True" --> block1
-  block2 -- "else" --> block0
-  block1 --> return
-  block0 --> return
-```
-
-## Function 2
-### Source
-```python
-def func():
-    if False:
-        return 0
-    else:
-        return 1
-```
-
-### Control Flow Graph
-```mermaid
-flowchart TD
-  start(("Start"))
-  return(("End"))
-  block0["return 0\n"]
-  block1["return 1\n"]
-  block2["if False:
-        return 0
-    else:
-        return 1\n"]
-
-  start --> block2
-  block2 -- "False" --> block0
-  block2 -- "else" --> block1
-  block1 --> return
-  block0 --> return
-```
-
-## Function 3
-### Source
-```python
-def func():
-    if True:
-        return 1
-    else:
-        return 0
-```
-
-### Control Flow Graph
-```mermaid
-flowchart TD
-  start(("Start"))
-  return(("End"))
-  block0["return 1\n"]
-  block1["return 0\n"]
-  block2["if True:
-        return 1
-    else:
-        return 0\n"]
-
-  start --> block2
-  block2 -- "True" --> block0
-  block2 -- "else" --> block1
-  block1 --> return
-  block0 --> return
-```
-
-## Function 4
-### Source
-```python
-def func():
-    if False:
-        return 0
-    else:
-        return 1
-    return "unreachable"
-```
-
-### Control Flow Graph
-```mermaid
-flowchart TD
-  start(("Start"))
-  return(("End"))
-  block0["return #quot;unreachable#quot;\n"]
-  block1["return 0\n"]
-  block2["return 1\n"]
-  block3["if False:
-        return 0
-    else:
-        return 1\n"]
-
-  start --> block3
-  block3 -- "False" --> block1
-  block3 -- "else" --> block2
-  block2 --> return
-  block1 --> return
-  block0 --> return
-```
-
-## Function 5
-### Source
-```python
-def func():
-    if True:
-        return 1
-    else:
-        return 0
-    return "unreachable"
-```
-
-### Control Flow Graph
-```mermaid
-flowchart TD
-  start(("Start"))
-  return(("End"))
-  block0["return #quot;unreachable#quot;\n"]
-  block1["return 1\n"]
-  block2["return 0\n"]
-  block3["if True:
-        return 1
-    else:
-        return 0\n"]
-
-  start --> block3
-  block3 -- "True" --> block1
-  block3 -- "else" --> block2
-  block2 --> return
-  block1 --> return
-  block0 --> return
-```
-
-## Function 6
-### Source
-```python
-def func():
-    if True:
-        if True:
-            return 1
-        return 2
-    else:
-        return 3
-    return "unreachable2"
-```
-
-### Control Flow Graph
-```mermaid
-flowchart TD
-  start(("Start"))
-  return(("End"))
-  block0["return #quot;unreachable2#quot;\n"]
-  block1["return 2\n"]
-  block2["return 1\n"]
-  block3["if True:
-            return 1\n"]
-  block4["return 3\n"]
-  block5["if True:
-        if True:
-            return 1
-        return 2
-    else:
-        return 3\n"]
-
-  start --> block5
-  block5 -- "True" --> block3
-  block5 -- "else" --> block4
-  block4 --> return
-  block3 -- "True" --> block2
-  block3 -- "else" --> block1
-  block2 --> return
-  block1 --> return
-  block0 --> return
-```
-
-## Function 7
-### Source
-```python
-def func():
-    if False:
-        return 0
-```
-
-### Control Flow Graph
-```mermaid
-flowchart TD
-  start(("Start"))
-  return(("End"))
-  block0[["`*(empty)*`"]]
-  block1["return 0\n"]
-  block2["if False:
-        return 0\n"]
-
-  start --> block2
-  block2 -- "False" --> block1
-  block2 -- "else" --> block0
-  block1 --> return
-  block0 --> return
-```
-
-## Function 8
-### Source
-```python
-def func():
-    if True:
-        return 1
-```
-
-### Control Flow Graph
-```mermaid
-flowchart TD
-  start(("Start"))
-  return(("End"))
-  block0[["`*(empty)*`"]]
-  block1["return 1\n"]
-  block2["if True:
-        return 1\n"]
-
-  start --> block2
-  block2 -- "True" --> block1
-  block2 -- "else" --> block0
-  block1 --> return
-  block0 --> return
-```
-
-## Function 9
-### Source
-```python
-def func():
-    if True:
-        return 1
-    elif False:
-        return 2
-    else:
-        return 0
-```
-
-### Control Flow Graph
-```mermaid
-flowchart TD
-  start(("Start"))
-  return(("End"))
-  block0["return 1\n"]
-  block1["return 0\n"]
-  block2["return 2\n"]
-  block3["if True:
-        return 1
-    elif False:
-        return 2
-    else:
-        return 0\n"]
-  block4["if True:
-        return 1
-    elif False:
-        return 2
-    else:
-        return 0\n"]
-
-  start --> block4
-  block4 -- "True" --> block0
-  block4 -- "else" --> block3
-  block3 -- "False" --> block2
-  block3 -- "else" --> block1
-  block2 --> return
-  block1 --> return
-  block0 --> return
-```
-
-## Function 10
-### Source
-```python
-def func():
-    if False:
-        return 1
-    elif True:
-        return 2
-    else:
-        return 0
-```
-
-### Control Flow Graph
-```mermaid
-flowchart TD
-  start(("Start"))
-  return(("End"))
-  block0["return 1\n"]
-  block1["return 0\n"]
-  block2["return 2\n"]
-  block3["if False:
-        return 1
-    elif True:
-        return 2
-    else:
-        return 0\n"]
-  block4["if False:
-        return 1
-    elif True:
-        return 2
-    else:
-        return 0\n"]
-
-  start --> block4
-  block4 -- "False" --> block0
-  block4 -- "else" --> block3
-  block3 -- "True" --> block2
-  block3 -- "else" --> block1
-  block2 --> return
-  block1 --> return
-  block0 --> return
-```
-
-## Function 11
-### Source
-```python
-def func():
-    if True:
-        if False:
-            return 0
-        elif True:
-            return 1
-        else:
-            return 2
-        return 3
-    elif True:
-        return 4
-    else:
-        return 5
-    return 6
-```
-
-### Control Flow Graph
-```mermaid
-flowchart TD
-  start(("Start"))
-  return(("End"))
-  block0["return 6\n"]
-  block1["return 3\n"]
-  block2["return 0\n"]
-  block3["return 2\n"]
-  block4["return 1\n"]
-  block5["if False:
-            return 0
-        elif True:
-            return 1
-        else:
-            return 2\n"]
-  block6["if False:
-            return 0
-        elif True:
-            return 1
-        else:
-            return 2\n"]
-  block7["return 5\n"]
-  block8["return 4\n"]
-  block9["if True:
-        if False:
-            return 0
-        elif True:
-            return 1
-        else:
-            return 2
-        return 3
-    elif True:
-        return 4
-    else:
-        return 5\n"]
-  block10["if True:
-        if False:
-            return 0
-        elif True:
-            return 1
-        else:
-            return 2
-        return 3
-    elif True:
-        return 4
-    else:
-        return 5\n"]
-
-  start --> block10
-  block10 -- "True" --> block6
-  block10 -- "else" --> block9
-  block9 -- "True" --> block8
-  block9 -- "else" --> block7
-  block8 --> return
-  block7 --> return
-  block6 -- "False" --> block2
-  block6 -- "else" --> block5
-  block5 -- "True" --> block4
-  block5 -- "else" --> block3
-  block4 --> return
-  block3 --> return
-  block2 --> return
-  block1 --> return
-  block0 --> return
-```
-
-## Function 12
-### Source
-```python
-def func():
-    if False:
-        return "unreached"
-    elif False:
-        return "also unreached"
-    return "reached"
-```
-
-### Control Flow Graph
-```mermaid
-flowchart TD
-  start(("Start"))
-  return(("End"))
-  block0["return #quot;reached#quot;\n"]
-  block1["return #quot;unreached#quot;\n"]
-  block2["return #quot;also unreached#quot;\n"]
-  block3["if False:
-        return #quot;unreached#quot;
-    elif False:
-        return #quot;also unreached#quot;\n"]
-  block4["if False:
-        return #quot;unreached#quot;
-    elif False:
-        return #quot;also unreached#quot;\n"]
-
-  start --> block4
-  block4 -- "False" --> block1
-  block4 -- "else" --> block3
-  block3 -- "False" --> block2
-  block3 -- "else" --> block0
-  block2 --> return
-  block1 --> return
-  block0 --> return
-```
-
-## Function 13
-### Source
-```python
-def func(self, obj: BytesRep) -> bytes:
-    data = obj["data"]
-
-    if isinstance(data, str):
-        return base64.b64decode(data)
-    elif isinstance(data, Buffer):
-        buffer = data
-    else:
-        id = data["id"]
-
-        if id in self._buffers:
-            buffer = self._buffers[id]
-        else:
-            self.error(f"can't resolve buffer '{id}'")
-
-    return buffer.data
-```
-
-### Control Flow Graph
-```mermaid
-flowchart TD
-  start(("Start"))
-  return(("End"))
-  block0["return buffer.data\n"]
-  block1["return base64.b64decode(data)\n"]
-  block2["buffer = self._buffers[id]\n"]
-  block3["self.error(f#quot;can't resolve buffer '{id}'#quot;)\n"]
-  block4["id = data[#quot;id#quot;]\nif id in self._buffers:
-            buffer = self._buffers[id]
-        else:
-            self.error(f#quot;can't resolve buffer '{id}'#quot;)\n"]
-  block5["buffer = data\n"]
-  block6["if isinstance(data, str):
-        return base64.b64decode(data)
-    elif isinstance(data, Buffer):
-        buffer = data
-    else:
-        id = data[#quot;id#quot;]
-
-        if id in self._buffers:
-            buffer = self._buffers[id]
-        else:
-            self.error(f#quot;can't resolve buffer '{id}'#quot;)\n"]
-  block7["data = obj[#quot;data#quot;]\nif isinstance(data, str):
-        return base64.b64decode(data)
-    elif isinstance(data, Buffer):
-        buffer = data
-    else:
-        id = data[#quot;id#quot;]
-
-        if id in self._buffers:
-            buffer = self._buffers[id]
-        else:
-            self.error(f#quot;can't resolve buffer '{id}'#quot;)\n"]
-
-  start --> block7
-  block7 -- "isinstance(data, str)" --> block1
-  block7 -- "else" --> block6
-  block6 -- "isinstance(data, Buffer)" --> block5
-  block6 -- "else" --> block4
-  block5 --> block0
-  block4 -- "id in self._buffers" --> block2
-  block4 -- "else" --> block3
-  block3 --> block0
-  block2 --> block0
-  block1 --> return
-  block0 --> return
-```
-
-

crates/ruff_linter/src/rules/ruff/rules/snapshots/ruff_linter__rules__ruff__rules__unreachable__tests__match.py.md.snap

@@ -1,815 +0,0 @@
----
-source: crates/ruff_linter/src/rules/ruff/rules/unreachable.rs
-description: "This is a Mermaid graph. You can use https://mermaid.live to visualize it as a diagram."
----
-## Function 0
-### Source
-```python
-def func(status):
-    match status:
-        case _:
-            return 0
-    return "unreachable"
-```
-
-### Control Flow Graph
-```mermaid
-flowchart TD
-  start(("Start"))
-  return(("End"))
-  block0["return #quot;unreachable#quot;\n"]
-  block1["return 0\n"]
-  block2["match status:
-        case _:
-            return 0\n"]
-
-  start --> block2
-  block2 --> block1
-  block1 --> return
-  block0 --> return
-```
-
-## Function 1
-### Source
-```python
-def func(status):
-    match status:
-        case 1:
-            return 1
-    return 0
-```
-
-### Control Flow Graph
-```mermaid
-flowchart TD
-  start(("Start"))
-  return(("End"))
-  block0["return 0\n"]
-  block1["return 1\n"]
-  block2["match status:
-        case 1:
-            return 1\n"]
-
-  start --> block2
-  block2 -- "case 1" --> block1
-  block2 -- "else" --> block0
-  block1 --> return
-  block0 --> return
-```
-
-## Function 2
-### Source
-```python
-def func(status):
-    match status:
-        case 1:
-            return 1
-        case _:
-            return 0
-```
-
-### Control Flow Graph
-```mermaid
-flowchart TD
-  start(("Start"))
-  return(("End"))
-  block0["return 0\n"]
-  block1["match status:
-        case 1:
-            return 1
-        case _:
-            return 0\n"]
-  block2["return 1\n"]
-  block3["match status:
-        case 1:
-            return 1
-        case _:
-            return 0\n"]
-
-  start --> block3
-  block3 -- "case 1" --> block2
-  block3 -- "else" --> block1
-  block2 --> return
-  block1 --> block0
-  block0 --> return
-```
-
-## Function 3
-### Source
-```python
-def func(status):
-    match status:
-        case 1 | 2 | 3:
-            return 5
-    return 6
-```
-
-### Control Flow Graph
-```mermaid
-flowchart TD
-  start(("Start"))
-  return(("End"))
-  block0["return 6\n"]
-  block1["return 5\n"]
-  block2["match status:
-        case 1 | 2 | 3:
-            return 5\n"]
-
-  start --> block2
-  block2 -- "case 1 | 2 | 3" --> block1
-  block2 -- "else" --> block0
-  block1 --> return
-  block0 --> return
-```
-
-## Function 4
-### Source
-```python
-def func(status):
-    match status:
-        case 1 | 2 | 3:
-            return 5
-        case _:
-            return 10
-    return 0
-```
-
-### Control Flow Graph
-```mermaid
-flowchart TD
-  start(("Start"))
-  return(("End"))
-  block0["return 0\n"]
-  block1["return 10\n"]
-  block2["match status:
-        case 1 | 2 | 3:
-            return 5
-        case _:
-            return 10\n"]
-  block3["return 5\n"]
-  block4["match status:
-        case 1 | 2 | 3:
-            return 5
-        case _:
-            return 10\n"]
-
-  start --> block4
-  block4 -- "case 1 | 2 | 3" --> block3
-  block4 -- "else" --> block2
-  block3 --> return
-  block2 --> block1
-  block1 --> return
-  block0 --> return
-```
-
-## Function 5
-### Source
-```python
-def func(status):
-    match status:
-        case 0:
-            return 0
-        case 1:
-            return 1
-        case 1:
-            return "1 again"
-        case _:
-            return 3
-```
-
-### Control Flow Graph
-```mermaid
-flowchart TD
-  start(("Start"))
-  return(("End"))
-  block0["return 3\n"]
-  block1["match status:
-        case 0:
-            return 0
-        case 1:
-            return 1
-        case 1:
-            return #quot;1 again#quot;
-        case _:
-            return 3\n"]
-  block2["return #quot;1 again#quot;\n"]
-  block3["match status:
-        case 0:
-            return 0
-        case 1:
-            return 1
-        case 1:
-            return #quot;1 again#quot;
-        case _:
-            return 3\n"]
-  block4["return 1\n"]
-  block5["match status:
-        case 0:
-            return 0
-        case 1:
-            return 1
-        case 1:
-            return #quot;1 again#quot;
-        case _:
-            return 3\n"]
-  block6["return 0\n"]
-  block7["match status:
-        case 0:
-            return 0
-        case 1:
-            return 1
-        case 1:
-            return #quot;1 again#quot;
-        case _:
-            return 3\n"]
-
-  start --> block7
-  block7 -- "case 0" --> block6
-  block7 -- "else" --> block5
-  block6 --> return
-  block5 -- "case 1" --> block4
-  block5 -- "else" --> block3
-  block4 --> return
-  block3 -- "case 1" --> block2
-  block3 -- "else" --> block1
-  block2 --> return
-  block1 --> block0
-  block0 --> return
-```
-
-## Function 6
-### Source
-```python
-def func(status):
-    i = 0
-    match status, i:
-        case _, _:
-            return 0
-```
-
-### Control Flow Graph
-```mermaid
-flowchart TD
-  start(("Start"))
-  return(("End"))
-  block0[["`*(empty)*`"]]
-  block1["return 0\n"]
-  block2["match status, i:
-        case _, _:
-            return 0\n"]
-  block3["i = 0\n"]
-
-  start --> block3
-  block3 --> block2
-  block2 -- "case _, _" --> block1
-  block2 -- "else" --> block0
-  block1 --> return
-  block0 --> return
-```
-
-## Function 7
-### Source
-```python
-def func(status):
-    i = 0
-    match status, i:
-        case _, 0:
-            return 0
-        case _, 2:
-            return 0
-```
-
-### Control Flow Graph
-```mermaid
-flowchart TD
-  start(("Start"))
-  return(("End"))
-  block0[["`*(empty)*`"]]
-  block1["return 0\n"]
-  block2["match status, i:
-        case _, 0:
-            return 0
-        case _, 2:
-            return 0\n"]
-  block3["return 0\n"]
-  block4["match status, i:
-        case _, 0:
-            return 0
-        case _, 2:
-            return 0\n"]
-  block5["i = 0\n"]
-
-  start --> block5
-  block5 --> block4
-  block4 -- "case _, 0" --> block3
-  block4 -- "else" --> block2
-  block3 --> return
-  block2 -- "case _, 2" --> block1
-  block2 -- "else" --> block0
-  block1 --> return
-  block0 --> return
-```
-
-## Function 8
-### Source
-```python
-def func(point):
-    match point:
-        case (0, 0):
-            print("Origin")
-        case _:
-            raise ValueError("oops")
-```
-
-### Control Flow Graph
-```mermaid
-flowchart TD
-  start(("Start"))
-  return(("End"))
-  block0[["`*(empty)*`"]]
-  block1["raise ValueError(#quot;oops#quot;)\n"]
-  block2["match point:
-        case (0, 0):
-            print(#quot;Origin#quot;)
-        case _:
-            raise ValueError(#quot;oops#quot;)\n"]
-  block3["print(#quot;Origin#quot;)\n"]
-  block4["match point:
-        case (0, 0):
-            print(#quot;Origin#quot;)
-        case _:
-            raise ValueError(#quot;oops#quot;)\n"]
-
-  start --> block4
-  block4 -- "case (0, 0)" --> block3
-  block4 -- "else" --> block2
-  block3 --> block0
-  block2 --> block1
-  block1 --> return
-  block0 --> return
-```
-
-## Function 9
-### Source
-```python
-def func(point):
-    match point:
-        case (0, 0):
-            print("Origin")
-        case (0, y):
-            print(f"Y={y}")
-        case (x, 0):
-            print(f"X={x}")
-        case (x, y):
-            print(f"X={x}, Y={y}")
-        case _:
-            raise ValueError("Not a point")
-```
-
-### Control Flow Graph
-```mermaid
-flowchart TD
-  start(("Start"))
-  return(("End"))
-  block0[["`*(empty)*`"]]
-  block1["raise ValueError(#quot;Not a point#quot;)\n"]
-  block2["match point:
-        case (0, 0):
-            print(#quot;Origin#quot;)
-        case (0, y):
-            print(f#quot;Y={y}#quot;)
-        case (x, 0):
-            print(f#quot;X={x}#quot;)
-        case (x, y):
-            print(f#quot;X={x}, Y={y}#quot;)
-        case _:
-            raise ValueError(#quot;Not a point#quot;)\n"]
-  block3["print(f#quot;X={x}, Y={y}#quot;)\n"]
-  block4["match point:
-        case (0, 0):
-            print(#quot;Origin#quot;)
-        case (0, y):
-            print(f#quot;Y={y}#quot;)
-        case (x, 0):
-            print(f#quot;X={x}#quot;)
-        case (x, y):
-            print(f#quot;X={x}, Y={y}#quot;)
-        case _:
-            raise ValueError(#quot;Not a point#quot;)\n"]
-  block5["print(f#quot;X={x}#quot;)\n"]
-  block6["match point:
-        case (0, 0):
-            print(#quot;Origin#quot;)
-        case (0, y):
-            print(f#quot;Y={y}#quot;)
-        case (x, 0):
-            print(f#quot;X={x}#quot;)
-        case (x, y):
-            print(f#quot;X={x}, Y={y}#quot;)
-        case _:
-            raise ValueError(#quot;Not a point#quot;)\n"]
-  block7["print(f#quot;Y={y}#quot;)\n"]
-  block8["match point:
-        case (0, 0):
-            print(#quot;Origin#quot;)
-        case (0, y):
-            print(f#quot;Y={y}#quot;)
-        case (x, 0):
-            print(f#quot;X={x}#quot;)
-        case (x, y):
-            print(f#quot;X={x}, Y={y}#quot;)
-        case _:
-            raise ValueError(#quot;Not a point#quot;)\n"]
-  block9["print(#quot;Origin#quot;)\n"]
-  block10["match point:
-        case (0, 0):
-            print(#quot;Origin#quot;)
-        case (0, y):
-            print(f#quot;Y={y}#quot;)
-        case (x, 0):
-            print(f#quot;X={x}#quot;)
-        case (x, y):
-            print(f#quot;X={x}, Y={y}#quot;)
-        case _:
-            raise ValueError(#quot;Not a point#quot;)\n"]
-
-  start --> block10
-  block10 -- "case (0, 0)" --> block9
-  block10 -- "else" --> block8
-  block9 --> block0
-  block8 -- "case (0, y)" --> block7
-  block8 -- "else" --> block6
-  block7 --> block0
-  block6 -- "case (x, 0)" --> block5
-  block6 -- "else" --> block4
-  block5 --> block0
-  block4 -- "case (x, y)" --> block3
-  block4 -- "else" --> block2
-  block3 --> block0
-  block2 --> block1
-  block1 --> return
-  block0 --> return
-```
-
-## Function 10
-### Source
-```python
-def where_is(point):
-    class Point:
-        x: int
-        y: int
-
-    match point:
-        case Point(x=0, y=0):
-            print("Origin")
-        case Point(x=0, y=y):
-            print(f"Y={y}")
-        case Point(x=x, y=0):
-            print(f"X={x}")
-        case Point():
-            print("Somewhere else")
-        case _:
-            print("Not a point")
-```
-
-### Control Flow Graph
-```mermaid
-flowchart TD
-  start(("Start"))
-  return(("End"))
-  block0[["`*(empty)*`"]]
-  block1["print(#quot;Not a point#quot;)\n"]
-  block2["match point:
-        case Point(x=0, y=0):
-            print(#quot;Origin#quot;)
-        case Point(x=0, y=y):
-            print(f#quot;Y={y}#quot;)
-        case Point(x=x, y=0):
-            print(f#quot;X={x}#quot;)
-        case Point():
-            print(#quot;Somewhere else#quot;)
-        case _:
-            print(#quot;Not a point#quot;)\n"]
-  block3["print(#quot;Somewhere else#quot;)\n"]
-  block4["match point:
-        case Point(x=0, y=0):
-            print(#quot;Origin#quot;)
-        case Point(x=0, y=y):
-            print(f#quot;Y={y}#quot;)
-        case Point(x=x, y=0):
-            print(f#quot;X={x}#quot;)
-        case Point():
-            print(#quot;Somewhere else#quot;)
-        case _:
-            print(#quot;Not a point#quot;)\n"]
-  block5["print(f#quot;X={x}#quot;)\n"]
-  block6["match point:
-        case Point(x=0, y=0):
-            print(#quot;Origin#quot;)
-        case Point(x=0, y=y):
-            print(f#quot;Y={y}#quot;)
-        case Point(x=x, y=0):
-            print(f#quot;X={x}#quot;)
-        case Point():
-            print(#quot;Somewhere else#quot;)
-        case _:
-            print(#quot;Not a point#quot;)\n"]
-  block7["print(f#quot;Y={y}#quot;)\n"]
-  block8["match point:
-        case Point(x=0, y=0):
-            print(#quot;Origin#quot;)
-        case Point(x=0, y=y):
-            print(f#quot;Y={y}#quot;)
-        case Point(x=x, y=0):
-            print(f#quot;X={x}#quot;)
-        case Point():
-            print(#quot;Somewhere else#quot;)
-        case _:
-            print(#quot;Not a point#quot;)\n"]
-  block9["print(#quot;Origin#quot;)\n"]
-  block10["match point:
-        case Point(x=0, y=0):
-            print(#quot;Origin#quot;)
-        case Point(x=0, y=y):
-            print(f#quot;Y={y}#quot;)
-        case Point(x=x, y=0):
-            print(f#quot;X={x}#quot;)
-        case Point():
-            print(#quot;Somewhere else#quot;)
-        case _:
-            print(#quot;Not a point#quot;)\n"]
-  block11["class Point:
-        x: int
-        y: int\n"]
-
-  start --> block11
-  block11 --> block10
-  block10 -- "case Point(x=0, y=0)" --> block9
-  block10 -- "else" --> block8
-  block9 --> block0
-  block8 -- "case Point(x=0, y=y)" --> block7
-  block8 -- "else" --> block6
-  block7 --> block0
-  block6 -- "case Point(x=x, y=0)" --> block5
-  block6 -- "else" --> block4
-  block5 --> block0
-  block4 -- "case Point()" --> block3
-  block4 -- "else" --> block2
-  block3 --> block0
-  block2 --> block1
-  block1 --> block0
-  block0 --> return
-```
-
-## Function 11
-### Source
-```python
-def func(points):
-    match points:
-        case []:
-            print("No points")
-        case [Point(0, 0)]:
-            print("The origin")
-        case [Point(x, y)]:
-            print(f"Single point {x}, {y}")
-        case [Point(0, y1), Point(0, y2)]:
-            print(f"Two on the Y axis at {y1}, {y2}")
-        case _:
-            print("Something else")
-```
-
-### Control Flow Graph
-```mermaid
-flowchart TD
-  start(("Start"))
-  return(("End"))
-  block0[["`*(empty)*`"]]
-  block1["print(#quot;Something else#quot;)\n"]
-  block2["match points:
-        case []:
-            print(#quot;No points#quot;)
-        case [Point(0, 0)]:
-            print(#quot;The origin#quot;)
-        case [Point(x, y)]:
-            print(f#quot;Single point {x}, {y}#quot;)
-        case [Point(0, y1), Point(0, y2)]:
-            print(f#quot;Two on the Y axis at {y1}, {y2}#quot;)
-        case _:
-            print(#quot;Something else#quot;)\n"]
-  block3["print(f#quot;Two on the Y axis at {y1}, {y2}#quot;)\n"]
-  block4["match points:
-        case []:
-            print(#quot;No points#quot;)
-        case [Point(0, 0)]:
-            print(#quot;The origin#quot;)
-        case [Point(x, y)]:
-            print(f#quot;Single point {x}, {y}#quot;)
-        case [Point(0, y1), Point(0, y2)]:
-            print(f#quot;Two on the Y axis at {y1}, {y2}#quot;)
-        case _:
-            print(#quot;Something else#quot;)\n"]
-  block5["print(f#quot;Single point {x}, {y}#quot;)\n"]
-  block6["match points:
-        case []:
-            print(#quot;No points#quot;)
-        case [Point(0, 0)]:
-            print(#quot;The origin#quot;)
-        case [Point(x, y)]:
-            print(f#quot;Single point {x}, {y}#quot;)
-        case [Point(0, y1), Point(0, y2)]:
-            print(f#quot;Two on the Y axis at {y1}, {y2}#quot;)
-        case _:
-            print(#quot;Something else#quot;)\n"]
-  block7["print(#quot;The origin#quot;)\n"]
-  block8["match points:
-        case []:
-            print(#quot;No points#quot;)
-        case [Point(0, 0)]:
-            print(#quot;The origin#quot;)
-        case [Point(x, y)]:
-            print(f#quot;Single point {x}, {y}#quot;)
-        case [Point(0, y1), Point(0, y2)]:
-            print(f#quot;Two on the Y axis at {y1}, {y2}#quot;)
-        case _:
-            print(#quot;Something else#quot;)\n"]
-  block9["print(#quot;No points#quot;)\n"]
-  block10["match points:
-        case []:
-            print(#quot;No points#quot;)
-        case [Point(0, 0)]:
-            print(#quot;The origin#quot;)
-        case [Point(x, y)]:
-            print(f#quot;Single point {x}, {y}#quot;)
-        case [Point(0, y1), Point(0, y2)]:
-            print(f#quot;Two on the Y axis at {y1}, {y2}#quot;)
-        case _:
-            print(#quot;Something else#quot;)\n"]
-
-  start --> block10
-  block10 -- "case []" --> block9
-  block10 -- "else" --> block8
-  block9 --> block0
-  block8 -- "case [Point(0, 0)]" --> block7
-  block8 -- "else" --> block6
-  block7 --> block0
-  block6 -- "case [Point(x, y)]" --> block5
-  block6 -- "else" --> block4
-  block5 --> block0
-  block4 -- "case [Point(0, y1), Point(0, y2)]" --> block3
-  block4 -- "else" --> block2
-  block3 --> block0
-  block2 --> block1
-  block1 --> block0
-  block0 --> return
-```
-
-## Function 12
-### Source
-```python
-def func(point):
-    match point:
-        case Point(x, y) if x == y:
-            print(f"Y=X at {x}")
-        case Point(x, y):
-            print(f"Not on the diagonal")
-```
-
-### Control Flow Graph
-```mermaid
-flowchart TD
-  start(("Start"))
-  return(("End"))
-  block0[["`*(empty)*`"]]
-  block1["print(f#quot;Not on the diagonal#quot;)\n"]
-  block2["match point:
-        case Point(x, y) if x == y:
-            print(f#quot;Y=X at {x}#quot;)
-        case Point(x, y):
-            print(f#quot;Not on the diagonal#quot;)\n"]
-  block3["print(f#quot;Y=X at {x}#quot;)\n"]
-  block4["match point:
-        case Point(x, y) if x == y:
-            print(f#quot;Y=X at {x}#quot;)
-        case Point(x, y):
-            print(f#quot;Not on the diagonal#quot;)\n"]
-
-  start --> block4
-  block4 -- "case Point(x, y) if x == y" --> block3
-  block4 -- "else" --> block2
-  block3 --> block0
-  block2 -- "case Point(x, y)" --> block1
-  block2 -- "else" --> block0
-  block1 --> block0
-  block0 --> return
-```
-
-## Function 13
-### Source
-```python
-def func():
-    from enum import Enum
-    class Color(Enum):
-        RED = 'red'
-        GREEN = 'green'
-        BLUE = 'blue'
-
-    color = Color(input("Enter your choice of 'red', 'blue' or 'green': "))
-
-    match color:
-        case Color.RED:
-            print("I see red!")
-        case Color.GREEN:
-            print("Grass is green")
-        case Color.BLUE:
-            print("I'm feeling the blues :(")
-```
-
-### Control Flow Graph
-```mermaid
-flowchart TD
-  start(("Start"))
-  return(("End"))
-  block0[["`*(empty)*`"]]
-  block1["print(#quot;I'm feeling the blues :(#quot;)\n"]
-  block2["match color:
-        case Color.RED:
-            print(#quot;I see red!#quot;)
-        case Color.GREEN:
-            print(#quot;Grass is green#quot;)
-        case Color.BLUE:
-            print(#quot;I'm feeling the blues :(#quot;)\n"]
-  block3["print(#quot;Grass is green#quot;)\n"]
-  block4["match color:
-        case Color.RED:
-            print(#quot;I see red!#quot;)
-        case Color.GREEN:
-            print(#quot;Grass is green#quot;)
-        case Color.BLUE:
-            print(#quot;I'm feeling the blues :(#quot;)\n"]
-  block5["print(#quot;I see red!#quot;)\n"]
-  block6["match color:
-        case Color.RED:
-            print(#quot;I see red!#quot;)
-        case Color.GREEN:
-            print(#quot;Grass is green#quot;)
-        case Color.BLUE:
-            print(#quot;I'm feeling the blues :(#quot;)\n"]
-  block7["from enum import Enum\nclass Color(Enum):
-        RED = 'red'
-        GREEN = 'green'
-        BLUE = 'blue'\ncolor = Color(input(#quot;Enter your choice of 'red', 'blue' or 'green': #quot;))\n"]
-
-  start --> block7
-  block7 --> block6
-  block6 -- "case Color.RED" --> block5
-  block6 -- "else" --> block4
-  block5 --> block0
-  block4 -- "case Color.GREEN" --> block3
-  block4 -- "else" --> block2
-  block3 --> block0
-  block2 -- "case Color.BLUE" --> block1
-  block2 -- "else" --> block0
-  block1 --> block0
-  block0 --> return
-```
-
-## Function 14
-### Source
-```python
-def func(point):
-    match point:
-        case (0, 0):
-            print("Origin")
-        case foo:
-            raise ValueError("oops")
-```
-
-### Control Flow Graph
-```mermaid
-flowchart TD
-  start(("Start"))
-  return(("End"))
-  block0[["`*(empty)*`"]]
-  block1["raise ValueError(#quot;oops#quot;)\n"]
-  block2["match point:
-        case (0, 0):
-            print(#quot;Origin#quot;)
-        case foo:
-            raise ValueError(#quot;oops#quot;)\n"]
-  block3["print(#quot;Origin#quot;)\n"]
-  block4["match point:
-        case (0, 0):
-            print(#quot;Origin#quot;)
-        case foo:
-            raise ValueError(#quot;oops#quot;)\n"]
-
-  start --> block4
-  block4 -- "case (0, 0)" --> block3
-  block4 -- "else" --> block2
-  block3 --> block0
-  block2 --> block1
-  block1 --> return
-  block0 --> return
-```
-
-

crates/ruff_linter/src/rules/ruff/rules/snapshots/ruff_linter__rules__ruff__rules__unreachable__tests__raise.py.md.snap

@@ -1,41 +0,0 @@
----
-source: crates/ruff_linter/src/rules/ruff/rules/unreachable.rs
-description: "This is a Mermaid graph. You can use https://mermaid.live to visualize it as a diagram."
----
-## Function 0
-### Source
-```python
-def func():
-    raise Exception
-```
-
-### Control Flow Graph
-```mermaid
-flowchart TD
-  start(("Start"))
-  return(("End"))
-  block0["raise Exception\n"]
-
-  start --> block0
-  block0 --> return
-```
-
-## Function 1
-### Source
-```python
-def func():
-    raise "a glass!"
-```
-
-### Control Flow Graph
-```mermaid
-flowchart TD
-  start(("Start"))
-  return(("End"))
-  block0["raise #quot;a glass!#quot;\n"]
-
-  start --> block0
-  block0 --> return
-```
-
-

crates/ruff_linter/src/rules/ruff/rules/snapshots/ruff_linter__rules__ruff__rules__unreachable__tests__simple.py.md.snap

@@ -1,136 +0,0 @@
----
-source: crates/ruff_linter/src/rules/ruff/rules/unreachable.rs
-description: "This is a Mermaid graph. You can use https://mermaid.live to visualize it as a diagram."
----
-## Function 0
-### Source
-```python
-def func():
-    pass
-```
-
-### Control Flow Graph
-```mermaid
-flowchart TD
-  start(("Start"))
-  return(("End"))
-  block0["pass\n"]
-
-  start --> block0
-  block0 --> return
-```
-
-## Function 1
-### Source
-```python
-def func():
-    pass
-```
-
-### Control Flow Graph
-```mermaid
-flowchart TD
-  start(("Start"))
-  return(("End"))
-  block0["pass\n"]
-
-  start --> block0
-  block0 --> return
-```
-
-## Function 2
-### Source
-```python
-def func():
-    return
-```
-
-### Control Flow Graph
-```mermaid
-flowchart TD
-  start(("Start"))
-  return(("End"))
-  block0["return\n"]
-
-  start --> block0
-  block0 --> return
-```
-
-## Function 3
-### Source
-```python
-def func():
-    return 1
-```
-
-### Control Flow Graph
-```mermaid
-flowchart TD
-  start(("Start"))
-  return(("End"))
-  block0["return 1\n"]
-
-  start --> block0
-  block0 --> return
-```
-
-## Function 4
-### Source
-```python
-def func():
-    return 1
-    return "unreachable"
-```
-
-### Control Flow Graph
-```mermaid
-flowchart TD
-  start(("Start"))
-  return(("End"))
-  block0["return #quot;unreachable#quot;\n"]
-  block1["return 1\n"]
-
-  start --> block1
-  block1 --> return
-  block0 --> return
-```
-
-## Function 5
-### Source
-```python
-def func():
-    i = 0
-```
-
-### Control Flow Graph
-```mermaid
-flowchart TD
-  start(("Start"))
-  return(("End"))
-  block0["i = 0\n"]
-
-  start --> block0
-  block0 --> return
-```
-
-## Function 6
-### Source
-```python
-def func():
-    i = 0
-    i += 2
-    return i
-```
-
-### Control Flow Graph
-```mermaid
-flowchart TD
-  start(("Start"))
-  return(("End"))
-  block0["i = 0\ni += 2\nreturn i\n"]
-
-  start --> block0
-  block0 --> return
-```
-
-

crates/ruff_linter/src/rules/ruff/rules/snapshots/ruff_linter__rules__ruff__rules__unreachable__tests__while.py.md.snap

@@ -1,527 +0,0 @@
----
-source: crates/ruff_linter/src/rules/ruff/rules/unreachable.rs
-description: "This is a Mermaid graph. You can use https://mermaid.live to visualize it as a diagram."
----
-## Function 0
-### Source
-```python
-def func():
-    while False:
-        return "unreachable"
-    return 1
-```
-
-### Control Flow Graph
-```mermaid
-flowchart TD
-  start(("Start"))
-  return(("End"))
-  block0["return 1\n"]
-  block1["return #quot;unreachable#quot;\n"]
-  block2["while False:
-        return #quot;unreachable#quot;\n"]
-
-  start --> block2
-  block2 -- "False" --> block1
-  block2 -- "else" --> block0
-  block1 --> return
-  block0 --> return
-```
-
-## Function 1
-### Source
-```python
-def func():
-    while False:
-        return "unreachable"
-    else:
-        return 1
-```
-
-### Control Flow Graph
-```mermaid
-flowchart TD
-  start(("Start"))
-  return(("End"))
-  block0["return #quot;unreachable#quot;\n"]
-  block1["return 1\n"]
-  block2["while False:
-        return #quot;unreachable#quot;
-    else:
-        return 1\n"]
-
-  start --> block2
-  block2 -- "False" --> block0
-  block2 -- "else" --> block1
-  block1 --> return
-  block0 --> return
-```
-
-## Function 2
-### Source
-```python
-def func():
-    while False:
-        return "unreachable"
-    else:
-        return 1
-    return "also unreachable"
-```
-
-### Control Flow Graph
-```mermaid
-flowchart TD
-  start(("Start"))
-  return(("End"))
-  block0["return #quot;also unreachable#quot;\n"]
-  block1["return #quot;unreachable#quot;\n"]
-  block2["return 1\n"]
-  block3["while False:
-        return #quot;unreachable#quot;
-    else:
-        return 1\n"]
-
-  start --> block3
-  block3 -- "False" --> block1
-  block3 -- "else" --> block2
-  block2 --> return
-  block1 --> return
-  block0 --> return
-```
-
-## Function 3
-### Source
-```python
-def func():
-    while True:
-        return 1
-    return "unreachable"
-```
-
-### Control Flow Graph
-```mermaid
-flowchart TD
-  start(("Start"))
-  return(("End"))
-  block0["return #quot;unreachable#quot;\n"]
-  block1["return 1\n"]
-  block2["while True:
-        return 1\n"]
-
-  start --> block2
-  block2 -- "True" --> block1
-  block2 -- "else" --> block0
-  block1 --> return
-  block0 --> return
-```
-
-## Function 4
-### Source
-```python
-def func():
-    while True:
-        return 1
-    else:
-        return "unreachable"
-```
-
-### Control Flow Graph
-```mermaid
-flowchart TD
-  start(("Start"))
-  return(("End"))
-  block0["return 1\n"]
-  block1["return #quot;unreachable#quot;\n"]
-  block2["while True:
-        return 1
-    else:
-        return #quot;unreachable#quot;\n"]
-
-  start --> block2
-  block2 -- "True" --> block0
-  block2 -- "else" --> block1
-  block1 --> return
-  block0 --> return
-```
-
-## Function 5
-### Source
-```python
-def func():
-    while True:
-        return 1
-    else:
-        return "unreachable"
-    return "also unreachable"
-```
-
-### Control Flow Graph
-```mermaid
-flowchart TD
-  start(("Start"))
-  return(("End"))
-  block0["return #quot;also unreachable#quot;\n"]
-  block1["return 1\n"]
-  block2["return #quot;unreachable#quot;\n"]
-  block3["while True:
-        return 1
-    else:
-        return #quot;unreachable#quot;\n"]
-
-  start --> block3
-  block3 -- "True" --> block1
-  block3 -- "else" --> block2
-  block2 --> return
-  block1 --> return
-  block0 --> return
-```
-
-## Function 6
-### Source
-```python
-def func():
-    i = 0
-    while False:
-        i += 1
-    return i
-```
-
-### Control Flow Graph
-```mermaid
-flowchart TD
-  start(("Start"))
-  return(("End"))
-  block0["return i\n"]
-  block1["i += 1\n"]
-  block2["i = 0\nwhile False:
-        i += 1\n"]
-
-  start --> block2
-  block2 -- "False" --> block1
-  block2 -- "else" --> block0
-  block1 --> block2
-  block0 --> return
-```
-
-## Function 7
-### Source
-```python
-def func():
-    i = 0
-    while True:
-        i += 1
-    return i
-```
-
-### Control Flow Graph
-```mermaid
-flowchart TD
-  start(("Start"))
-  return(("End"))
-  block0["return i\n"]
-  block1["i += 1\n"]
-  block2["i = 0\nwhile True:
-        i += 1\n"]
-
-  start --> block2
-  block2 -- "True" --> block1
-  block2 -- "else" --> block0
-  block1 --> block2
-  block0 --> return
-```
-
-## Function 8
-### Source
-```python
-def func():
-    while True:
-        pass
-    return 1
-```
-
-### Control Flow Graph
-```mermaid
-flowchart TD
-  start(("Start"))
-  return(("End"))
-  block0["return 1\n"]
-  block1["pass\n"]
-  block2["while True:
-        pass\n"]
-
-  start --> block2
-  block2 -- "True" --> block1
-  block2 -- "else" --> block0
-  block1 --> block2
-  block0 --> return
-```
-
-## Function 9
-### Source
-```python
-def func():
-    i = 0
-    while True:
-        if True:
-            print("ok")
-        i += 1
-    return i
-```
-
-### Control Flow Graph
-```mermaid
-flowchart TD
-  start(("Start"))
-  return(("End"))
-  block0["return i\n"]
-  block1["i += 1\n"]
-  block2["print(#quot;ok#quot;)\n"]
-  block3["if True:
-            print(#quot;ok#quot;)\n"]
-  block4["i = 0\nwhile True:
-        if True:
-            print(#quot;ok#quot;)
-        i += 1\n"]
-
-  start --> block4
-  block4 -- "True" --> block3
-  block4 -- "else" --> block0
-  block3 -- "True" --> block2
-  block3 -- "else" --> block1
-  block2 --> block1
-  block1 --> block4
-  block0 --> return
-```
-
-## Function 10
-### Source
-```python
-def func():
-    i = 0
-    while True:
-        if False:
-            print("ok")
-        i += 1
-    return i
-```
-
-### Control Flow Graph
-```mermaid
-flowchart TD
-  start(("Start"))
-  return(("End"))
-  block0["return i\n"]
-  block1["i += 1\n"]
-  block2["print(#quot;ok#quot;)\n"]
-  block3["if False:
-            print(#quot;ok#quot;)\n"]
-  block4["i = 0\nwhile True:
-        if False:
-            print(#quot;ok#quot;)
-        i += 1\n"]
-
-  start --> block4
-  block4 -- "True" --> block3
-  block4 -- "else" --> block0
-  block3 -- "False" --> block2
-  block3 -- "else" --> block1
-  block2 --> block1
-  block1 --> block4
-  block0 --> return
-```
-
-## Function 11
-### Source
-```python
-def func():
-    while True:
-        if True:
-            return 1
-    return 0
-```
-
-### Control Flow Graph
-```mermaid
-flowchart TD
-  start(("Start"))
-  return(("End"))
-  block0["return 0\n"]
-  block1["return 1\n"]
-  block2["if True:
-            return 1\n"]
-  block3["while True:
-        if True:
-            return 1\n"]
-
-  start --> block3
-  block3 -- "True" --> block2
-  block3 -- "else" --> block0
-  block2 -- "True" --> block1
-  block2 -- "else" --> block3
-  block1 --> return
-  block0 --> return
-```
-
-## Function 12
-### Source
-```python
-def func():
-    while True:
-        continue
-```
-
-### Control Flow Graph
-```mermaid
-flowchart TD
-  start(("Start"))
-  return(("End"))
-  block0[["`*(empty)*`"]]
-  block1["continue\n"]
-  block2["while True:
-        continue\n"]
-
-  start --> block2
-  block2 -- "True" --> block1
-  block2 -- "else" --> block0
-  block1 --> block2
-  block0 --> return
-```
-
-## Function 13
-### Source
-```python
-def func():
-    while False:
-        continue
-```
-
-### Control Flow Graph
-```mermaid
-flowchart TD
-  start(("Start"))
-  return(("End"))
-  block0[["`*(empty)*`"]]
-  block1["continue\n"]
-  block2["while False:
-        continue\n"]
-
-  start --> block2
-  block2 -- "False" --> block1
-  block2 -- "else" --> block0
-  block1 --> block2
-  block0 --> return
-```
-
-## Function 14
-### Source
-```python
-def func():
-    while True:
-        break
-```
-
-### Control Flow Graph
-```mermaid
-flowchart TD
-  start(("Start"))
-  return(("End"))
-  block0[["`*(empty)*`"]]
-  block1["break\n"]
-  block2["while True:
-        break\n"]
-
-  start --> block2
-  block2 -- "True" --> block1
-  block2 -- "else" --> block0
-  block1 --> block0
-  block0 --> return
-```
-
-## Function 15
-### Source
-```python
-def func():
-    while False:
-        break
-```
-
-### Control Flow Graph
-```mermaid
-flowchart TD
-  start(("Start"))
-  return(("End"))
-  block0[["`*(empty)*`"]]
-  block1["break\n"]
-  block2["while False:
-        break\n"]
-
-  start --> block2
-  block2 -- "False" --> block1
-  block2 -- "else" --> block0
-  block1 --> block0
-  block0 --> return
-```
-
-## Function 16
-### Source
-```python
-def func():
-    while True:
-        if True:
-            continue
-```
-
-### Control Flow Graph
-```mermaid
-flowchart TD
-  start(("Start"))
-  return(("End"))
-  block0[["`*(empty)*`"]]
-  block1["continue\n"]
-  block2["if True:
-            continue\n"]
-  block3["while True:
-        if True:
-            continue\n"]
-
-  start --> block3
-  block3 -- "True" --> block2
-  block3 -- "else" --> block0
-  block2 -- "True" --> block1
-  block2 -- "else" --> block3
-  block1 --> block3
-  block0 --> return
-```
-
-## Function 17
-### Source
-```python
-def func():
-    while True:
-        if True:
-            break
-```
-
-### Control Flow Graph
-```mermaid
-flowchart TD
-  start(("Start"))
-  return(("End"))
-  block0[["`*(empty)*`"]]
-  block1["break\n"]
-  block2["if True:
-            break\n"]
-  block3["while True:
-        if True:
-            break\n"]
-
-  start --> block3
-  block3 -- "True" --> block2
-  block3 -- "else" --> block0
-  block2 -- "True" --> block1
-  block2 -- "else" --> block3
-  block1 --> block0
-  block0 --> return
-```
-
-

crates/ruff_linter/src/rules/ruff/rules/static_key_dict_comprehension.rs

@@ -2,7 +2,7 @@ use rustc_hash::FxHashMap;
 
 use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};
-use ruff_python_ast::helpers::NameFinder;
+use ruff_python_ast::helpers::StoredNameFinder;
 use ruff_python_ast::visitor::Visitor;
 use ruff_python_ast::{self as ast, Expr};
 use ruff_text_size::Ranged;
@@ -51,9 +51,9 @@ impl Violation for StaticKeyDictComprehension {
 pub(crate) fn static_key_dict_comprehension(checker: &mut Checker, dict_comp: &ast::ExprDictComp) {
     // Collect the bound names in the comprehension's generators.
     let names = {
-        let mut visitor = NameFinder::default();
+        let mut visitor = StoredNameFinder::default();
         for generator in &dict_comp.generators {
-            visitor.visit_expr(&generator.target);
+            visitor.visit_comprehension(generator);
         }
         visitor.names
     };

crates/ruff_linter/src/rules/ruff/snapshots/ruff_linter__rules__ruff__tests__RUF011_RUF011.py.snap

@@ -1,80 +1,90 @@
 ---
 source: crates/ruff_linter/src/rules/ruff/mod.rs
 ---
-RUF011.py:15:2: RUF011 Dictionary comprehension uses static key: `"key"`
+RUF011.py:17:2: RUF011 Dictionary comprehension uses static key: `"key"`
    |
-14 | # Errors
-15 | {"key": value.upper() for value in data}
+16 | # Errors
+17 | {"key": value.upper() for value in data}
    |  ^^^^^ RUF011
-16 | {True: value.upper() for value in data}
-17 | {0: value.upper() for value in data}
+18 | {True: value.upper() for value in data}
+19 | {0: value.upper() for value in data}
    |
 
-RUF011.py:16:2: RUF011 Dictionary comprehension uses static key: `True`
+RUF011.py:18:2: RUF011 Dictionary comprehension uses static key: `True`
    |
-14 | # Errors
-15 | {"key": value.upper() for value in data}
-16 | {True: value.upper() for value in data}
+16 | # Errors
+17 | {"key": value.upper() for value in data}
+18 | {True: value.upper() for value in data}
    |  ^^^^ RUF011
-17 | {0: value.upper() for value in data}
-18 | {(1, "a"): value.upper() for value in data}  # Constant tuple
+19 | {0: value.upper() for value in data}
+20 | {(1, "a"): value.upper() for value in data}  # Constant tuple
    |
 
-RUF011.py:17:2: RUF011 Dictionary comprehension uses static key: `0`
+RUF011.py:19:2: RUF011 Dictionary comprehension uses static key: `0`
    |
-15 | {"key": value.upper() for value in data}
-16 | {True: value.upper() for value in data}
-17 | {0: value.upper() for value in data}
+17 | {"key": value.upper() for value in data}
+18 | {True: value.upper() for value in data}
+19 | {0: value.upper() for value in data}
    |  ^ RUF011
-18 | {(1, "a"): value.upper() for value in data}  # Constant tuple
-19 | {constant: value.upper() for value in data}
+20 | {(1, "a"): value.upper() for value in data}  # Constant tuple
+21 | {constant: value.upper() for value in data}
    |
 
-RUF011.py:18:2: RUF011 Dictionary comprehension uses static key: `(1, "a")`
+RUF011.py:20:2: RUF011 Dictionary comprehension uses static key: `(1, "a")`
    |
-16 | {True: value.upper() for value in data}
-17 | {0: value.upper() for value in data}
-18 | {(1, "a"): value.upper() for value in data}  # Constant tuple
+18 | {True: value.upper() for value in data}
+19 | {0: value.upper() for value in data}
+20 | {(1, "a"): value.upper() for value in data}  # Constant tuple
    |  ^^^^^^^^ RUF011
-19 | {constant: value.upper() for value in data}
-20 | {constant + constant: value.upper() for value in data}
+21 | {constant: value.upper() for value in data}
+22 | {constant + constant: value.upper() for value in data}
    |
 
-RUF011.py:19:2: RUF011 Dictionary comprehension uses static key: `constant`
+RUF011.py:21:2: RUF011 Dictionary comprehension uses static key: `constant`
    |
-17 | {0: value.upper() for value in data}
-18 | {(1, "a"): value.upper() for value in data}  # Constant tuple
-19 | {constant: value.upper() for value in data}
+19 | {0: value.upper() for value in data}
+20 | {(1, "a"): value.upper() for value in data}  # Constant tuple
+21 | {constant: value.upper() for value in data}
    |  ^^^^^^^^ RUF011
-20 | {constant + constant: value.upper() for value in data}
-21 | {constant.attribute: value.upper() for value in data}
+22 | {constant + constant: value.upper() for value in data}
+23 | {constant.attribute: value.upper() for value in data}
    |
 
-RUF011.py:20:2: RUF011 Dictionary comprehension uses static key: `constant + constant`
+RUF011.py:22:2: RUF011 Dictionary comprehension uses static key: `constant + constant`
    |
-18 | {(1, "a"): value.upper() for value in data}  # Constant tuple
-19 | {constant: value.upper() for value in data}
-20 | {constant + constant: value.upper() for value in data}
+20 | {(1, "a"): value.upper() for value in data}  # Constant tuple
+21 | {constant: value.upper() for value in data}
+22 | {constant + constant: value.upper() for value in data}
    |  ^^^^^^^^^^^^^^^^^^^ RUF011
-21 | {constant.attribute: value.upper() for value in data}
-22 | {constant[0]: value.upper() for value in data}
+23 | {constant.attribute: value.upper() for value in data}
+24 | {constant[0]: value.upper() for value in data}
    |
 
-RUF011.py:21:2: RUF011 Dictionary comprehension uses static key: `constant.attribute`
+RUF011.py:23:2: RUF011 Dictionary comprehension uses static key: `constant.attribute`
    |
-19 | {constant: value.upper() for value in data}
-20 | {constant + constant: value.upper() for value in data}
-21 | {constant.attribute: value.upper() for value in data}
+21 | {constant: value.upper() for value in data}
+22 | {constant + constant: value.upper() for value in data}
+23 | {constant.attribute: value.upper() for value in data}
    |  ^^^^^^^^^^^^^^^^^^ RUF011
-22 | {constant[0]: value.upper() for value in data}
+24 | {constant[0]: value.upper() for value in data}
+25 | {tokens: token for token in tokens}
    |
 
-RUF011.py:22:2: RUF011 Dictionary comprehension uses static key: `constant[0]`
+RUF011.py:24:2: RUF011 Dictionary comprehension uses static key: `constant[0]`
    |
-20 | {constant + constant: value.upper() for value in data}
-21 | {constant.attribute: value.upper() for value in data}
-22 | {constant[0]: value.upper() for value in data}
+22 | {constant + constant: value.upper() for value in data}
+23 | {constant.attribute: value.upper() for value in data}
+24 | {constant[0]: value.upper() for value in data}
    |  ^^^^^^^^^^^ RUF011
+25 | {tokens: token for token in tokens}
+   |
+
+RUF011.py:25:2: RUF011 Dictionary comprehension uses static key: `tokens`
+   |
+23 | {constant.attribute: value.upper() for value in data}
+24 | {constant[0]: value.upper() for value in data}
+25 | {tokens: token for token in tokens}
+   |  ^^^^^^ RUF011
    |
 
 

crates/ruff_linter/src/rules/ruff/snapshots/ruff_linter__rules__ruff__tests__RUF014_RUF014.py.snap

@@ -1,249 +0,0 @@
----
-source: crates/ruff_linter/src/rules/ruff/mod.rs
----
-RUF014.py:3:5: RUF014 Unreachable code in after_return
-  |
-1 | def after_return():
-2 |     return "reachable"
-3 |     return "unreachable"
-  |     ^^^^^^^^^^^^^^^^^^^^ RUF014
-4 | 
-5 | async def also_works_on_async_functions():
-  |
-
-RUF014.py:7:5: RUF014 Unreachable code in also_works_on_async_functions
-  |
-5 | async def also_works_on_async_functions():
-6 |     return "reachable"
-7 |     return "unreachable"
-  |     ^^^^^^^^^^^^^^^^^^^^ RUF014
-8 | 
-9 | def if_always_true():
-  |
-
-RUF014.py:12:5: RUF014 Unreachable code in if_always_true
-   |
-10 |     if True:
-11 |         return "reachable"
-12 |     return "unreachable"
-   |     ^^^^^^^^^^^^^^^^^^^^ RUF014
-13 | 
-14 | def if_always_false():
-   |
-
-RUF014.py:16:9: RUF014 Unreachable code in if_always_false
-   |
-14 | def if_always_false():
-15 |     if False:
-16 |         return "unreachable"
-   |         ^^^^^^^^^^^^^^^^^^^^ RUF014
-17 |     return "reachable"
-   |
-
-RUF014.py:21:9: RUF014 Unreachable code in if_elif_always_false
-   |
-19 | def if_elif_always_false():
-20 |     if False:
-21 |         return "unreachable"
-   |         ^^^^^^^^^^^^^^^^^^^^ RUF014
-22 |     elif False:
-23 |         return "also unreachable"
-   |
-
-RUF014.py:23:9: RUF014 Unreachable code in if_elif_always_false
-   |
-21 |         return "unreachable"
-22 |     elif False:
-23 |         return "also unreachable"
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^ RUF014
-24 |     return "reachable"
-   |
-
-RUF014.py:28:9: RUF014 Unreachable code in if_elif_always_true
-   |
-26 | def if_elif_always_true():
-27 |     if False:
-28 |         return "unreachable"
-   |         ^^^^^^^^^^^^^^^^^^^^ RUF014
-29 |     elif True:
-30 |         return "reachable"
-   |
-
-RUF014.py:31:5: RUF014 Unreachable code in if_elif_always_true
-   |
-29 |     elif True:
-30 |         return "reachable"
-31 |     return "also unreachable"
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^ RUF014
-32 | 
-33 | def ends_with_if():
-   |
-
-RUF014.py:35:9: RUF014 Unreachable code in ends_with_if
-   |
-33 | def ends_with_if():
-34 |     if False:
-35 |         return "unreachable"
-   |         ^^^^^^^^^^^^^^^^^^^^ RUF014
-36 |     else:
-37 |         return "reachable"
-   |
-
-RUF014.py:42:5: RUF014 Unreachable code in infinite_loop
-   |
-40 |     while True:
-41 |         continue
-42 |     return "unreachable"
-   |     ^^^^^^^^^^^^^^^^^^^^ RUF014
-43 | 
-44 | '''  TODO: we could determine these, but we don't yet.
-   |
-
-RUF014.py:75:5: RUF014 Unreachable code in match_wildcard
-   |
-73 |         case _:
-74 |             return "reachable"
-75 |     return "unreachable"
-   |     ^^^^^^^^^^^^^^^^^^^^ RUF014
-76 | 
-77 | def match_case_and_wildcard(status):
-   |
-
-RUF014.py:83:5: RUF014 Unreachable code in match_case_and_wildcard
-   |
-81 |         case _:
-82 |             return "reachable"
-83 |     return "unreachable"
-   |     ^^^^^^^^^^^^^^^^^^^^ RUF014
-84 | 
-85 | def raise_exception():
-   |
-
-RUF014.py:87:5: RUF014 Unreachable code in raise_exception
-   |
-85 | def raise_exception():
-86 |     raise Exception
-87 |     return "unreachable"
-   |     ^^^^^^^^^^^^^^^^^^^^ RUF014
-88 | 
-89 | def while_false():
-   |
-
-RUF014.py:91:9: RUF014 Unreachable code in while_false
-   |
-89 | def while_false():
-90 |     while False:
-91 |         return "unreachable"
-   |         ^^^^^^^^^^^^^^^^^^^^ RUF014
-92 |     return "reachable"
-   |
-
-RUF014.py:96:9: RUF014 Unreachable code in while_false_else
-   |
-94 | def while_false_else():
-95 |     while False:
-96 |         return "unreachable"
-   |         ^^^^^^^^^^^^^^^^^^^^ RUF014
-97 |     else:
-98 |         return "reachable"
-   |
-
-RUF014.py:102:9: RUF014 Unreachable code in while_false_else_return
-    |
-100 | def while_false_else_return():
-101 |     while False:
-102 |         return "unreachable"
-    |         ^^^^^^^^^^^^^^^^^^^^ RUF014
-103 |     else:
-104 |         return "reachable"
-    |
-
-RUF014.py:105:5: RUF014 Unreachable code in while_false_else_return
-    |
-103 |     else:
-104 |         return "reachable"
-105 |     return "also unreachable"
-    |     ^^^^^^^^^^^^^^^^^^^^^^^^^ RUF014
-106 | 
-107 | def while_true():
-    |
-
-RUF014.py:110:5: RUF014 Unreachable code in while_true
-    |
-108 |     while True:
-109 |         return "reachable"
-110 |     return "unreachable"
-    |     ^^^^^^^^^^^^^^^^^^^^ RUF014
-111 | 
-112 | def while_true_else():
-    |
-
-RUF014.py:116:9: RUF014 Unreachable code in while_true_else
-    |
-114 |         return "reachable"
-115 |     else:
-116 |         return "unreachable"
-    |         ^^^^^^^^^^^^^^^^^^^^ RUF014
-117 | 
-118 | def while_true_else_return():
-    |
-
-RUF014.py:122:9: RUF014 Unreachable code in while_true_else_return
-    |
-120 |         return "reachable"
-121 |     else:
-122 |         return "unreachable"
-    |         ^^^^^^^^^^^^^^^^^^^^ RUF014
-123 |     return "also unreachable"
-    |
-
-RUF014.py:123:5: RUF014 Unreachable code in while_true_else_return
-    |
-121 |     else:
-122 |         return "unreachable"
-123 |     return "also unreachable"
-    |     ^^^^^^^^^^^^^^^^^^^^^^^^^ RUF014
-124 | 
-125 | def while_false_var_i():
-    |
-
-RUF014.py:128:9: RUF014 Unreachable code in while_false_var_i
-    |
-126 |     i = 0
-127 |     while False:
-128 |         i += 1
-    |         ^^^^^^ RUF014
-129 |     return i
-    |
-
-RUF014.py:135:5: RUF014 Unreachable code in while_true_var_i
-    |
-133 |     while True:
-134 |         i += 1
-135 |     return i
-    |     ^^^^^^^^ RUF014
-136 | 
-137 | def while_infinite():
-    |
-
-RUF014.py:140:5: RUF014 Unreachable code in while_infinite
-    |
-138 |     while True:
-139 |         pass
-140 |     return "unreachable"
-    |     ^^^^^^^^^^^^^^^^^^^^ RUF014
-141 | 
-142 | def while_if_true():
-    |
-
-RUF014.py:146:5: RUF014 Unreachable code in while_if_true
-    |
-144 |         if True:
-145 |             return "reachable"
-146 |     return "unreachable"
-    |     ^^^^^^^^^^^^^^^^^^^^ RUF014
-147 | 
-148 | # Test case found in the Bokeh repository that trigger a false positive.
-    |
-
-

crates/ruff_linter/src/settings/fix_safety_table.rs

@@ -1,4 +1,4 @@
-use std::fmt::Debug;
+use std::fmt::{Debug, Display, Formatter};
 
 use ruff_diagnostics::Applicability;
 use ruff_macros::CacheKey;
@@ -6,6 +6,7 @@ use rustc_hash::FxHashMap;
 use strum::IntoEnumIterator;
 
 use crate::{
+    display_settings,
     registry::{Rule, RuleSet},
     rule_selector::{PreviewOptions, Specificity},
     RuleSelector,
@@ -95,6 +96,20 @@ impl FixSafetyTable {
     }
 }
 
+impl Display for FixSafetyTable {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        display_settings! {
+            formatter = f,
+            namespace = "linter.safety_table",
+            fields = [
+                self.forced_safe,
+                self.forced_unsafe
+            ]
+        }
+        Ok(())
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

crates/ruff_linter/src/settings/mod.rs

@@ -2,10 +2,9 @@
 //! command-line options. Structure is optimized for internal usage, as opposed
 //! to external visibility or parsing.
 
+use std::fmt::{Display, Formatter};
 use std::path::{Path, PathBuf};
 
-use anyhow::Result;
-use globset::{Glob, GlobMatcher};
 use once_cell::sync::Lazy;
 use path_absolutize::path_dedot;
 use regex::Regex;
@@ -15,7 +14,7 @@ use crate::codes::RuleCodePrefix;
 use ruff_macros::CacheKey;
 
 use crate::line_width::LineLength;
-use crate::registry::{Linter, Rule, RuleSet};
+use crate::registry::{Linter, Rule};
 use crate::rules::{
     flake8_annotations, flake8_bandit, flake8_bugbear, flake8_builtins, flake8_comprehensions,
     flake8_copyright, flake8_errmsg, flake8_gettext, flake8_implicit_str_concat,
@@ -23,7 +22,7 @@ use crate::rules::{
     flake8_tidy_imports, flake8_type_checking, flake8_unused_arguments, isort, mccabe, pep8_naming,
     pycodestyle, pydocstyle, pyflakes, pylint, pyupgrade,
 };
-use crate::settings::types::{ExtensionMapping, FilePatternSet, PerFileIgnore, PythonVersion};
+use crate::settings::types::{ExtensionMapping, FilePatternSet, PerFileIgnores, PythonVersion};
 use crate::{codes, RuleSelector};
 
 use super::line_width::IndentWidth;
@@ -38,19 +37,139 @@ pub mod flags;
 pub mod rule_table;
 pub mod types;
 
+/// `display_settings!` is a macro that can display and format struct fields in a readable,
+/// namespaced format. It's particularly useful at generating `Display` implementations
+/// for types used in settings.
+///
+/// # Example
+/// ```
+/// use std::fmt;
+/// use ruff_linter::display_settings;
+/// #[derive(Default)]
+/// struct Settings {
+///     option_a: bool,
+///     sub_settings: SubSettings,
+///     option_b: String,
+/// }
+///
+/// struct SubSettings {
+///     name: String
+/// }
+///
+/// impl Default for SubSettings {
+///     fn default() -> Self {
+///         Self { name: "Default Name".into() }
+///     }
+///
+/// }
+///
+/// impl fmt::Display for SubSettings {
+///     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+///         display_settings! {
+///             formatter = f,
+///             namespace = "sub_settings",
+///             fields = [
+///                 self.name | quoted
+///             ]
+///         }
+///         Ok(())
+///     }
+///
+/// }
+///
+/// impl fmt::Display for Settings {
+///     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+///         display_settings! {
+///             formatter = f,
+///             fields = [
+///                 self.option_a,
+///                 self.sub_settings | nested,
+///                 self.option_b | quoted,
+///             ]
+///         }
+///         Ok(())
+///     }
+///
+/// }
+///
+/// const EXPECTED_OUTPUT: &str = r#"option_a = false
+/// sub_settings.name = "Default Name"
+/// option_b = ""
+/// "#;
+///
+/// fn main() {
+///     let settings = Settings::default();
+///     assert_eq!(format!("{settings}"), EXPECTED_OUTPUT);
+/// }
+/// ```
+#[macro_export]
+macro_rules! display_settings {
+    (formatter = $fmt:ident, namespace = $namespace:literal, fields = [$($settings:ident.$field:ident $(| $modifier:tt)?),* $(,)?]) => {
+        {
+            const _PREFIX: &str = concat!($namespace, ".");
+            $(
+                display_settings!(@field $fmt, _PREFIX, $settings.$field $(| $modifier)?);
+            )*
+        }
+    };
+    (formatter = $fmt:ident, fields = [$($settings:ident.$field:ident $(| $modifier:tt)?),* $(,)?]) => {
+        {
+            const _PREFIX: &str = "";
+            $(
+                display_settings!(@field $fmt, _PREFIX, $settings.$field $(| $modifier)?);
+            )*
+        }
+    };
+    (@field $fmt:ident, $prefix:ident, $settings:ident.$field:ident | debug) => {
+        writeln!($fmt, "{}{} = {:?}", $prefix, stringify!($field), $settings.$field)?;
+    };
+    (@field $fmt:ident, $prefix:ident, $settings:ident.$field:ident | quoted) => {
+        writeln!($fmt, "{}{} = \"{}\"", $prefix, stringify!($field), $settings.$field)?;
+    };
+    (@field $fmt:ident, $prefix:ident, $settings:ident.$field:ident | nested) => {
+        write!($fmt, "{}", $settings.$field)?;
+    };
+    (@field $fmt:ident, $prefix:ident, $settings:ident.$field:ident | optional) => {
+        {
+            write!($fmt, "{}{} = ", $prefix, stringify!($field))?;
+            match &$settings.$field {
+                Some(value) => writeln!($fmt, "{}", value)?,
+                None        => writeln!($fmt, "none")?
+            };
+        }
+    };
+    (@field $fmt:ident, $prefix:ident, $settings:ident.$field:ident | array) => {
+        {
+            write!($fmt, "{}{} = ", $prefix, stringify!($field))?;
+            if $settings.$field.is_empty() {
+                writeln!($fmt, "[]")?;
+            } else {
+                writeln!($fmt, "[")?;
+                for elem in &$settings.$field {
+                    writeln!($fmt, "\t{elem},")?;
+                }
+                writeln!($fmt, "]")?;
+            }
+        }
+    };
+    (@field $fmt:ident, $prefix:ident, $settings:ident.$field:ident) => {
+        writeln!($fmt, "{}{} = {}", $prefix, stringify!($field), $settings.$field)?;
+    };
+}
+
 #[derive(Debug, CacheKey)]
 pub struct LinterSettings {
     pub exclude: FilePatternSet,
+    pub extension: ExtensionMapping,
     pub project_root: PathBuf,
 
     pub rules: RuleTable,
-    pub per_file_ignores: Vec<(GlobMatcher, GlobMatcher, RuleSet)>,
+    pub per_file_ignores: PerFileIgnores,
     pub fix_safety: FixSafetyTable,
 
     pub target_version: PythonVersion,
     pub preview: PreviewMode,
     pub explicit_preview_rules: bool,
-    pub extension: ExtensionMapping,
 
     // Rule-specific settings
     pub allowed_confusables: FxHashSet<char>,
@@ -93,6 +212,73 @@ pub struct LinterSettings {
     pub pyupgrade: pyupgrade::settings::Settings,
 }
 
+impl Display for LinterSettings {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        writeln!(f, "\n# Linter Settings")?;
+        display_settings! {
+            formatter = f,
+            namespace = "linter",
+            fields = [
+                self.exclude,
+                self.project_root | debug,
+
+                self.rules | nested,
+                self.per_file_ignores,
+                self.fix_safety | nested,
+
+                self.target_version | debug,
+                self.preview,
+                self.explicit_preview_rules,
+                self.extension | nested,
+
+                self.allowed_confusables | array,
+                self.builtins | array,
+                self.dummy_variable_rgx,
+                self.external | array,
+                self.ignore_init_module_imports,
+                self.logger_objects | array,
+                self.namespace_packages | debug,
+                self.src | debug,
+                self.tab_size,
+                self.line_length,
+                self.task_tags | array,
+                self.typing_modules | array,
+            ]
+        }
+        writeln!(f, "\n# Linter Plugins")?;
+        display_settings! {
+            formatter = f,
+            namespace = "linter",
+            fields = [
+                self.flake8_annotations | nested,
+                self.flake8_bandit | nested,
+                self.flake8_bugbear | nested,
+                self.flake8_builtins | nested,
+                self.flake8_comprehensions | nested,
+                self.flake8_copyright | nested,
+                self.flake8_errmsg | nested,
+                self.flake8_gettext | nested,
+                self.flake8_implicit_str_concat | nested,
+                self.flake8_import_conventions | nested,
+                self.flake8_pytest_style | nested,
+                self.flake8_quotes | nested,
+                self.flake8_self | nested,
+                self.flake8_tidy_imports | nested,
+                self.flake8_type_checking | nested,
+                self.flake8_unused_arguments | nested,
+                self.isort | nested,
+                self.mccabe | nested,
+                self.pep8_naming | nested,
+                self.pycodestyle | nested,
+                self.pyflakes | nested,
+                self.pylint | nested,
+                self.pyupgrade | nested,
+            ]
+        }
+        Ok(())
+    }
+}
+
 pub const DEFAULT_SELECTORS: &[RuleSelector] = &[
     RuleSelector::Linter(Linter::Pyflakes),
     // Only include pycodestyle rules that do not overlap with the formatter
@@ -152,7 +338,7 @@ impl LinterSettings {
             logger_objects: vec![],
             namespace_packages: vec![],
 
-            per_file_ignores: vec![],
+            per_file_ignores: PerFileIgnores::default(),
             fix_safety: FixSafetyTable::default(),
 
             src: vec![path_dedot::CWD.clone()],
@@ -204,22 +390,3 @@ impl Default for LinterSettings {
         Self::new(path_dedot::CWD.as_path())
     }
 }
-
-/// Given a list of patterns, create a `GlobSet`.
-pub fn resolve_per_file_ignores(
-    per_file_ignores: Vec<PerFileIgnore>,
-) -> Result<Vec<(GlobMatcher, GlobMatcher, RuleSet)>> {
-    per_file_ignores
-        .into_iter()
-        .map(|per_file_ignore| {
-            // Construct absolute path matcher.
-            let absolute =
-                Glob::new(&per_file_ignore.absolute.to_string_lossy())?.compile_matcher();
-
-            // Construct basename matcher.
-            let basename = Glob::new(&per_file_ignore.basename)?.compile_matcher();
-
-            Ok((absolute, basename, per_file_ignore.rules))
-        })
-        .collect()
-}

crates/ruff_linter/src/settings/rule_table.rs

@@ -1,5 +1,6 @@
-use std::fmt::Debug;
+use std::fmt::{Debug, Display, Formatter};
 
+use crate::display_settings;
 use ruff_macros::CacheKey;
 
 use crate::registry::{Rule, RuleSet, RuleSetIterator};
@@ -62,6 +63,20 @@ impl RuleTable {
     }
 }
 
+impl Display for RuleTable {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        display_settings! {
+            formatter = f,
+            namespace = "linter.rules",
+            fields = [
+                self.enabled,
+                self.should_fix
+            ]
+        }
+        Ok(())
+    }
+}
+
 impl FromIterator<Rule> for RuleTable {
     fn from_iter<T: IntoIterator<Item = Rule>>(iter: T) -> Self {
         let rules = RuleSet::from_iter(iter);

crates/ruff_linter/src/settings/types.rs

@@ -1,3 +1,4 @@
+use std::fmt::{Display, Formatter};
 use std::hash::{Hash, Hasher};
 use std::ops::Deref;
 use std::path::{Path, PathBuf};
@@ -5,7 +6,7 @@ use std::str::FromStr;
 use std::string::ToString;
 
 use anyhow::{bail, Result};
-use globset::{Glob, GlobSet, GlobSetBuilder};
+use globset::{Glob, GlobMatcher, GlobSet, GlobSetBuilder};
 use pep440_rs::{Version as Pep440Version, VersionSpecifiers};
 use rustc_hash::FxHashMap;
 use serde::{de, Deserialize, Deserializer, Serialize};
@@ -17,9 +18,9 @@ use ruff_diagnostics::Applicability;
 use ruff_macros::CacheKey;
 use ruff_python_ast::PySourceType;
 
-use crate::fs;
 use crate::registry::RuleSet;
 use crate::rule_selector::RuleSelector;
+use crate::{display_settings, fs};
 
 #[derive(
     Clone,
@@ -121,6 +122,15 @@ impl From<bool> for PreviewMode {
     }
 }
 
+impl Display for PreviewMode {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::Disabled => write!(f, "disabled"),
+            Self::Enabled => write!(f, "enabled"),
+        }
+    }
+}
+
 /// Toggle for unsafe fixes.
 /// `Hint` will not apply unsafe fixes but a message will be shown when they are available.
 /// `Disabled` will not apply unsafe fixes or show a message.
@@ -133,6 +143,20 @@ pub enum UnsafeFixes {
     Enabled,
 }
 
+impl Display for UnsafeFixes {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "{}",
+            match self {
+                Self::Hint => "hint",
+                Self::Disabled => "disabled",
+                Self::Enabled => "enabled",
+            }
+        )
+    }
+}
+
 impl From<bool> for UnsafeFixes {
     fn from(value: bool) -> Self {
         if value {
@@ -178,6 +202,19 @@ impl FilePattern {
     }
 }
 
+impl Display for FilePattern {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "{:?}",
+            match self {
+                Self::Builtin(pattern) => pattern,
+                Self::User(pattern, _) => pattern.as_str(),
+            }
+        )
+    }
+}
+
 impl FromStr for FilePattern {
     type Err = anyhow::Error;
 
@@ -192,9 +229,14 @@ impl FromStr for FilePattern {
 pub struct FilePatternSet {
     set: GlobSet,
     cache_key: u64,
+    // This field is only for displaying the internals
+    // of `set`.
+    #[allow(clippy::used_underscore_binding)]
+    _set_internals: Vec<FilePattern>,
 }
 
 impl FilePatternSet {
+    #[allow(clippy::used_underscore_binding)]
     pub fn try_from_iter<I>(patterns: I) -> Result<Self, anyhow::Error>
     where
         I: IntoIterator<Item = FilePattern>,
@@ -202,7 +244,10 @@ impl FilePatternSet {
         let mut builder = GlobSetBuilder::new();
         let mut hasher = CacheKeyHasher::new();
 
+        let mut _set_internals = vec![];
+
         for pattern in patterns {
+            _set_internals.push(pattern.clone());
             pattern.cache_key(&mut hasher);
             pattern.add_to(&mut builder)?;
         }
@@ -212,10 +257,26 @@ impl FilePatternSet {
         Ok(FilePatternSet {
             set,
             cache_key: hasher.finish(),
+            _set_internals,
         })
     }
 }
 
+impl Display for FilePatternSet {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        if self._set_internals.is_empty() {
+            write!(f, "[]")?;
+        } else {
+            writeln!(f, "[")?;
+            for pattern in &self._set_internals {
+                writeln!(f, "\t{pattern},")?;
+            }
+            write!(f, "]")?;
+        }
+        Ok(())
+    }
+}
+
 impl Deref for FilePatternSet {
     type Target = GlobSet;
 
@@ -388,9 +449,23 @@ pub struct ExtensionMapping {
 }
 
 impl ExtensionMapping {
-    /// Return the [`Language`] for the given extension.
-    pub fn get(&self, extension: &str) -> Option<Language> {
-        self.mapping.get(extension).copied()
+    /// Return the [`Language`] for the given file.
+    pub fn get(&self, path: &Path) -> Option<Language> {
+        let ext = path.extension()?.to_str()?;
+        self.mapping.get(ext).copied()
+    }
+}
+
+impl Display for ExtensionMapping {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        display_settings! {
+            formatter = f,
+            namespace = "linter.extension",
+            fields = [
+                self.mapping | debug
+            ]
+        }
+        Ok(())
     }
 }
 
@@ -428,6 +503,23 @@ pub enum SerializationFormat {
     Sarif,
 }
 
+impl Display for SerializationFormat {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::Text => write!(f, "text"),
+            Self::Json => write!(f, "json"),
+            Self::JsonLines => write!(f, "json_lines"),
+            Self::Junit => write!(f, "junit"),
+            Self::Grouped => write!(f, "grouped"),
+            Self::Github => write!(f, "github"),
+            Self::Gitlab => write!(f, "gitlab"),
+            Self::Pylint => write!(f, "pylint"),
+            Self::Azure => write!(f, "azure"),
+            Self::Sarif => write!(f, "sarif"),
+        }
+    }
+}
+
 impl Default for SerializationFormat {
     fn default() -> Self {
         Self::Text
@@ -467,3 +559,55 @@ impl Deref for Version {
 /// [`fnmatch`](https://docs.python.org/3/library/fnmatch.html) for
 /// pattern matching.
 pub type IdentifierPattern = glob::Pattern;
+
+#[derive(Debug, CacheKey, Default)]
+pub struct PerFileIgnores {
+    // Ordered as (absolute path matcher, basename matcher, rules)
+    ignores: Vec<(GlobMatcher, GlobMatcher, RuleSet)>,
+}
+
+impl PerFileIgnores {
+    /// Given a list of patterns, create a `GlobSet`.
+    pub fn resolve(per_file_ignores: Vec<PerFileIgnore>) -> Result<Self> {
+        let ignores: Result<Vec<_>> = per_file_ignores
+            .into_iter()
+            .map(|per_file_ignore| {
+                // Construct absolute path matcher.
+                let absolute =
+                    Glob::new(&per_file_ignore.absolute.to_string_lossy())?.compile_matcher();
+
+                // Construct basename matcher.
+                let basename = Glob::new(&per_file_ignore.basename)?.compile_matcher();
+
+                Ok((absolute, basename, per_file_ignore.rules))
+            })
+            .collect();
+        Ok(Self { ignores: ignores? })
+    }
+}
+
+impl Display for PerFileIgnores {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        if self.is_empty() {
+            write!(f, "{{}}")?;
+        } else {
+            writeln!(f, "{{")?;
+            for (absolute, basename, rules) in &self.ignores {
+                writeln!(
+                    f,
+                    "\t{{ absolute = {absolute:#?}, basename = {basename:#?}, rules = {rules} }},"
+                )?;
+            }
+            write!(f, "}}")?;
+        }
+        Ok(())
+    }
+}
+
+impl Deref for PerFileIgnores {
+    type Target = Vec<(GlobMatcher, GlobMatcher, RuleSet)>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.ignores
+    }
+}

crates/ruff_python_ast/src/helpers.rs

@@ -308,10 +308,13 @@ pub fn any_over_pattern(pattern: &Pattern, func: &dyn Fn(&Expr) -> bool) -> bool
     }
 }
 
-pub fn any_over_f_string_element(element: &FStringElement, func: &dyn Fn(&Expr) -> bool) -> bool {
+pub fn any_over_f_string_element(
+    element: &ast::FStringElement,
+    func: &dyn Fn(&Expr) -> bool,
+) -> bool {
     match element {
-        FStringElement::Literal(_) => false,
-        FStringElement::Expression(ast::FStringExpressionElement {
+        ast::FStringElement::Literal(_) => false,
+        ast::FStringElement::Expression(ast::FStringExpressionElement {
             expression,
             format_spec,
             ..
@@ -911,6 +914,27 @@ where
     }
 }
 
+/// A [`Visitor`] to collect all stored [`Expr::Name`] nodes in an AST.
+#[derive(Debug, Default)]
+pub struct StoredNameFinder<'a> {
+    /// A map from identifier to defining expression.
+    pub names: FxHashMap<&'a str, &'a ast::ExprName>,
+}
+
+impl<'a, 'b> Visitor<'b> for StoredNameFinder<'a>
+where
+    'b: 'a,
+{
+    fn visit_expr(&mut self, expr: &'a Expr) {
+        if let Expr::Name(name) = expr {
+            if name.ctx.is_store() {
+                self.names.insert(&name.id, name);
+            }
+        }
+        crate::visitor::walk_expr(self, expr);
+    }
+}
+
 /// A [`StatementVisitor`] that collects all `return` statements in a function or method.
 #[derive(Default)]
 pub struct ReturnStatementVisitor<'a> {
@@ -1171,21 +1195,10 @@ impl Truthiness {
             }
             Expr::NoneLiteral(_) => Self::Falsey,
             Expr::EllipsisLiteral(_) => Self::Truthy,
-            Expr::FString(ast::ExprFString { value, .. }) => {
-                if value.iter().all(|part| match part {
-                    ast::FStringPart::Literal(string_literal) => string_literal.is_empty(),
-                    ast::FStringPart::FString(f_string) => f_string.elements.is_empty(),
-                }) {
+            Expr::FString(f_string) => {
+                if is_empty_f_string(f_string) {
                     Self::Falsey
-                } else if value
-                    .elements()
-                    .any(|f_string_element| match f_string_element {
-                        ast::FStringElement::Literal(ast::FStringLiteralElement {
-                            value, ..
-                        }) => !value.is_empty(),
-                        ast::FStringElement::Expression(_) => true,
-                    })
-                {
+                } else if is_non_empty_f_string(f_string) {
                     Self::Truthy
                 } else {
                     Self::Unknown
@@ -1243,6 +1256,99 @@ impl Truthiness {
     }
 }
 
+/// Returns `true` if the expression definitely resolves to a non-empty string, when used as an
+/// f-string expression, or `false` if the expression may resolve to an empty string.
+fn is_non_empty_f_string(expr: &ast::ExprFString) -> bool {
+    fn inner(expr: &Expr) -> bool {
+        match expr {
+            // When stringified, these expressions are always non-empty.
+            Expr::Lambda(_) => true,
+            Expr::Dict(_) => true,
+            Expr::Set(_) => true,
+            Expr::ListComp(_) => true,
+            Expr::SetComp(_) => true,
+            Expr::DictComp(_) => true,
+            Expr::Compare(_) => true,
+            Expr::NumberLiteral(_) => true,
+            Expr::BooleanLiteral(_) => true,
+            Expr::NoneLiteral(_) => true,
+            Expr::EllipsisLiteral(_) => true,
+            Expr::List(_) => true,
+            Expr::Tuple(_) => true,
+
+            // These expressions must resolve to the inner expression.
+            Expr::IfExp(ast::ExprIfExp { body, orelse, .. }) => inner(body) && inner(orelse),
+            Expr::NamedExpr(ast::ExprNamedExpr { value, .. }) => inner(value),
+
+            // These expressions are complex. We can't determine whether they're empty or not.
+            Expr::BoolOp(ast::ExprBoolOp { .. }) => false,
+            Expr::BinOp(ast::ExprBinOp { .. }) => false,
+            Expr::UnaryOp(ast::ExprUnaryOp { .. }) => false,
+            Expr::GeneratorExp(_) => false,
+            Expr::Await(_) => false,
+            Expr::Yield(_) => false,
+            Expr::YieldFrom(_) => false,
+            Expr::Call(_) => false,
+            Expr::Attribute(_) => false,
+            Expr::Subscript(_) => false,
+            Expr::Starred(_) => false,
+            Expr::Name(_) => false,
+            Expr::Slice(_) => false,
+            Expr::IpyEscapeCommand(_) => false,
+
+            // These literals may or may not be empty.
+            Expr::FString(f_string) => is_non_empty_f_string(f_string),
+            Expr::StringLiteral(ast::ExprStringLiteral { value, .. }) => !value.is_empty(),
+            Expr::BytesLiteral(ast::ExprBytesLiteral { value, .. }) => !value.is_empty(),
+        }
+    }
+
+    expr.value.iter().any(|part| match part {
+        ast::FStringPart::Literal(string_literal) => !string_literal.is_empty(),
+        ast::FStringPart::FString(f_string) => {
+            f_string.elements.iter().all(|element| match element {
+                FStringElement::Literal(string_literal) => !string_literal.is_empty(),
+                FStringElement::Expression(f_string) => inner(&f_string.expression),
+            })
+        }
+    })
+}
+
+/// Returns `true` if the expression definitely resolves to the empty string, when used as an f-string
+/// expression.
+fn is_empty_f_string(expr: &ast::ExprFString) -> bool {
+    fn inner(expr: &Expr) -> bool {
+        match expr {
+            Expr::StringLiteral(ast::ExprStringLiteral { value, .. }) => value.is_empty(),
+            Expr::BytesLiteral(ast::ExprBytesLiteral { value, .. }) => value.is_empty(),
+            Expr::FString(ast::ExprFString { value, .. }) => {
+                value
+                    .elements()
+                    .all(|f_string_element| match f_string_element {
+                        FStringElement::Literal(ast::FStringLiteralElement { value, .. }) => {
+                            value.is_empty()
+                        }
+                        FStringElement::Expression(ast::FStringExpressionElement {
+                            expression,
+                            ..
+                        }) => inner(expression),
+                    })
+            }
+            _ => false,
+        }
+    }
+
+    expr.value.iter().all(|part| match part {
+        ast::FStringPart::Literal(string_literal) => string_literal.is_empty(),
+        ast::FStringPart::FString(f_string) => {
+            f_string.elements.iter().all(|element| match element {
+                FStringElement::Literal(string_literal) => string_literal.is_empty(),
+                FStringElement::Expression(f_string) => inner(&f_string.expression),
+            })
+        }
+    })
+}
+
 pub fn generate_comparison(
     left: &Expr,
     ops: &[CmpOp],

crates/ruff_python_ast/src/traversal.rs

@@ -79,3 +79,15 @@ pub fn next_sibling<'a>(stmt: &'a Stmt, suite: &'a Suite) -> Option<&'a Stmt> {
     }
     None
 }
+
+/// Given a [`Stmt`] and its containing [`Suite`], return the previous [`Stmt`] in the [`Suite`].
+pub fn prev_sibling<'a>(stmt: &'a Stmt, suite: &'a Suite) -> Option<&'a Stmt> {
+    let mut prev = None;
+    for sibling in suite {
+        if sibling == stmt {
+            return prev;
+        }
+        prev = Some(sibling);
+    }
+    None
+}

crates/ruff_python_formatter/src/options.rs

@@ -2,6 +2,7 @@ use ruff_formatter::printer::{LineEnding, PrinterOptions, SourceMapGeneration};
 use ruff_formatter::{FormatOptions, IndentStyle, IndentWidth, LineWidth};
 use ruff_macros::CacheKey;
 use ruff_python_ast::PySourceType;
+use std::fmt;
 use std::path::Path;
 use std::str::FromStr;
 
@@ -241,6 +242,16 @@ pub enum QuoteStyle {
     Preserve,
 }
 
+impl fmt::Display for QuoteStyle {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::Single => write!(f, "single"),
+            Self::Double => write!(f, "double"),
+            Self::Preserve => write!(f, "preserve"),
+        }
+    }
+}
+
 impl FromStr for QuoteStyle {
     type Err = &'static str;
 
@@ -277,6 +288,15 @@ impl MagicTrailingComma {
     }
 }
 
+impl fmt::Display for MagicTrailingComma {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::Respect => write!(f, "respect"),
+            Self::Ignore => write!(f, "ignore"),
+        }
+    }
+}
+
 impl FromStr for MagicTrailingComma {
     type Err = &'static str;
 
@@ -306,6 +326,15 @@ impl PreviewMode {
     }
 }
 
+impl fmt::Display for PreviewMode {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::Disabled => write!(f, "disabled"),
+            Self::Enabled => write!(f, "enabled"),
+        }
+    }
+}
+
 #[derive(Copy, Clone, Debug, Eq, PartialEq, Default, CacheKey)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 #[cfg_attr(feature = "serde", serde(rename_all = "lowercase"))]
@@ -323,6 +352,15 @@ impl DocstringCode {
     }
 }
 
+impl fmt::Display for DocstringCode {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::Disabled => write!(f, "disabled"),
+            Self::Enabled => write!(f, "enabled"),
+        }
+    }
+}
+
 #[derive(Copy, Clone, Default, Eq, PartialEq, CacheKey)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 #[cfg_attr(feature = "serde", serde(rename_all = "lowercase"))]
@@ -338,8 +376,8 @@ pub enum DocstringCodeLineWidth {
     Dynamic,
 }
 
-impl std::fmt::Debug for DocstringCodeLineWidth {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+impl fmt::Debug for DocstringCodeLineWidth {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match *self {
             DocstringCodeLineWidth::Fixed(v) => v.value().fmt(f),
             DocstringCodeLineWidth::Dynamic => "dynamic".fmt(f),
@@ -347,6 +385,15 @@ impl std::fmt::Debug for DocstringCodeLineWidth {
     }
 }
 
+impl fmt::Display for DocstringCodeLineWidth {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::Fixed(width) => width.fmt(f),
+            Self::Dynamic => write!(f, "dynamic"),
+        }
+    }
+}
+
 /// Responsible for deserializing the `DocstringCodeLineWidth::Dynamic`
 /// variant.
 fn deserialize_docstring_code_line_width_dynamic<'de, D>(d: D) -> Result<(), D::Error>

crates/ruff_python_parser/src/lexer.rs

@@ -31,8 +31,6 @@
 use std::iter::FusedIterator;
 use std::{char, cmp::Ordering, str::FromStr};
 
-use unicode_ident::{is_xid_continue, is_xid_start};
-
 use ruff_python_ast::{Int, IpyEscapeKind};
 use ruff_text_size::{TextLen, TextRange, TextSize};
 
@@ -1491,19 +1489,39 @@ const fn is_ascii_identifier_start(c: char) -> bool {
 
 // Checks if the character c is a valid starting character as described
 // in https://docs.python.org/3/reference/lexical_analysis.html#identifiers
+#[cold]
 fn is_unicode_identifier_start(c: char) -> bool {
-    is_xid_start(c)
+    unicode_ident::is_xid_start(c)
 }
 
 // Checks if the character c is a valid continuation character as described
 // in https://docs.python.org/3/reference/lexical_analysis.html#identifiers
 fn is_identifier_continuation(c: char) -> bool {
-    match c {
-        'a'..='z' | 'A'..='Z' | '_' | '0'..='9' => true,
-        c => is_xid_continue(c),
+    if c.is_ascii() {
+        ASCII_CONTINUE.0[c as usize]
+    } else {
+        is_unicode_identifier_continue(c)
     }
 }
 
+#[cold]
+fn is_unicode_identifier_continue(c: char) -> bool {
+    unicode_ident::is_xid_continue(c)
+}
+
+const T: bool = true;
+const F: bool = false;
+
+#[repr(C, align(64))]
+struct Align64<T>(pub(crate) T);
+
+static ASCII_CONTINUE: Align64<[bool; 128]> = Align64([
+    F, F, F, F, F, F, F, F, F, F, F, F, F, F, F, F, F, F, F, F, F, F, F, F, F, F, F, F, F, F, F, F,
+    F, F, F, F, F, F, F, F, F, F, F, F, F, F, F, F, T, T, T, T, T, T, T, T, T, T, F, F, F, F, F, F,
+    F, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, F, F, F, F, T,
+    F, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, F, F, F, F, F,
+]);
+
 /// Returns `true` for [whitespace](https://docs.python.org/3/reference/lexical_analysis.html#whitespace-between-tokens)
 /// characters.
 ///

crates/ruff_python_semantic/src/analyze/typing.rs

@@ -645,6 +645,24 @@ pub fn resolve_assignment<'a>(
 pub fn find_assigned_value<'a>(symbol: &str, semantic: &'a SemanticModel<'a>) -> Option<&'a Expr> {
     let binding_id = semantic.lookup_symbol(symbol)?;
     let binding = semantic.binding(binding_id);
+    find_binding_value(symbol, binding, semantic)
+}
+
+/// Find the assigned [`Expr`] for a given [`Binding`], if any.
+///
+/// For example given:
+/// ```python
+///  foo = 42
+///  (bar, bla) = 1, "str"
+/// ```
+///
+/// This function will return a `NumberLiteral` with value `Int(42)` when called with `foo` and a
+/// `StringLiteral` with value `"str"` when called with `bla`.
+pub fn find_binding_value<'a>(
+    symbol: &str,
+    binding: &Binding,
+    semantic: &'a SemanticModel,
+) -> Option<&'a Expr> {
     match binding.kind {
         // Ex) `x := 1`
         BindingKind::NamedExprAssignment => {

crates/ruff_python_semantic/src/scope.rs

@@ -129,6 +129,11 @@ impl<'a> Scope<'a> {
         self.shadowed_bindings.get(&id).copied()
     }
 
+    /// Returns an iterator over all bindings that the given binding shadows, including itself.
+    pub fn shadowed_bindings(&self, id: BindingId) -> impl Iterator<Item = BindingId> + '_ {
+        std::iter::successors(Some(id), |id| self.shadowed_bindings.get(id).copied())
+    }
+
     /// Adds a reference to a star import (e.g., `from sys import *`) to this scope.
     pub fn add_star_import(&mut self, import: StarImport<'a>) {
         self.star_imports.push(import);