Simplify comment

Cargo.lock

@@ -2399,7 +2399,6 @@ dependencies = [
  "ruff_text_size",
  "rustc-hash",
  "static_assertions",
- "test-case",
  "tiny-keccak",
  "unic-emoji-char",
  "unic-ucd-ident",

crates/ruff/resources/test/fixtures/flake8_annotations/annotation_presence.py

@@ -152,9 +152,3 @@ def f(a: Union[str, bytes, Any]) -> None: ...
 def f(a: Optional[Any]) -> None: ...
 def f(a: Annotated[Any, ...]) -> None: ...
 def f(a: "Union[str, bytes, Any]") -> None: ...
-
-
-class Foo:
-    @decorator()
-    def __init__(self: "Foo", foo: int):
-       ...

crates/ruff/resources/test/fixtures/flake8_bugbear/B006_extended.py

@@ -1,18 +0,0 @@
-import custom
-from custom import ImmutableTypeB
-
-
-def okay(foo: ImmutableTypeB = []):
-    ...
-
-
-def okay(foo: custom.ImmutableTypeA = []):
-    ...
-
-
-def okay(foo: custom.ImmutableTypeB = []):
-    ...
-
-
-def error_due_to_missing_import(foo: ImmutableTypeA = []):
-    ...

crates/ruff/resources/test/fixtures/flake8_comprehensions/C417.py

@@ -15,6 +15,11 @@ filter(func, map(lambda v: v, nums))
 _ = f"{set(map(lambda x: x % 2 == 0, nums))}"
 _ = f"{dict(map(lambda v: (v, v**2), nums))}"
 
+# Error, but unfixable.
+# For simple expressions, this could be: `(x if x else 1 for x in nums)`.
+# For more complex expressions, this would differ: `(x + 2 if x else 3 for x in nums)`.
+map(lambda x=1: x, nums)
+
 # False negatives.
 map(lambda x=2, y=1: x + y, nums, nums)
 set(map(lambda x, y: x, nums, nums))
@@ -32,8 +37,3 @@ map(lambda x: lambda: x, range(4))
 
 # Error: the `x` is overridden by the inner lambda.
 map(lambda x: lambda x: x, range(4))
-
-# Ok because of the default parameters, and variadic arguments.
-map(lambda x=1: x, nums)
-map(lambda *args: len(args), range(4))
-map(lambda **kwargs: len(kwargs), range(4))

crates/ruff/resources/test/fixtures/flake8_import_conventions/defaults.py

@@ -9,7 +9,6 @@ def unconventional():
     import pandas
     import seaborn
     import tkinter
-    import networkx
 
 
 def unconventional_aliases():
@@ -19,7 +18,7 @@ def unconventional_aliases():
     import pandas as pdas
     import seaborn as sbrn
     import tkinter as tkr
-    import networkx as nxy
+
 
 def conventional_aliases():
     import altair as alt
@@ -28,4 +27,3 @@ def conventional_aliases():
     import pandas as pd
     import seaborn as sns
     import tkinter as tk
-    import networkx as nx

crates/ruff/resources/test/fixtures/flake8_pytest_style/PT018.py

@@ -43,12 +43,3 @@ message
 assert something  # OK
 assert something and something_else  # Error
 assert something and something_else and something_third  # Error
-
-
-def test_multiline():
-    assert something and something_else; x = 1
-
-    x = 1; assert something and something_else
-
-    x = 1; \
-        assert something and something_else

crates/ruff/resources/test/fixtures/flake8_return/RET503.py

@@ -320,9 +320,3 @@ def end_of_statement():
         if True:
             return "" \
                 ;  # type: ignore
-
-
-def end_of_file():
-    if False:
-        return 1
-    x = 2 \

crates/ruff/resources/test/fixtures/pydocstyle/D200.py

@@ -1,13 +0,0 @@
-def func():
-    """\
-    """
-
-
-def func():
-    """\\
-    """
-
-
-def func():
-    """\ \
-    """

crates/ruff/resources/test/fixtures/pyflakes/F401_0.py

@@ -99,16 +99,3 @@ import foo.bar as bop
 import foo.bar.baz
 
 print(bop.baz.read_csv("test.csv"))
-
-# Test: isolated deletions.
-if TYPE_CHECKING:
-    import a1
-
-    import a2
-
-
-match *0, 1, *2:
-    case 0,:
-        import b1
-
-        import b2

crates/ruff/resources/test/fixtures/pyflakes/F522.py

@@ -2,5 +2,6 @@
 "{bar}{}".format(1, bar=2, spam=3)  # F522
 "{bar:{spam}}".format(bar=2, spam=3)  # No issues
 "{bar:{spam}}".format(bar=2, spam=3, eggs=4, ham=5)  # F522
+# Not fixable
 (''
- .format(x=2))  # F522
+ .format(x=2))

crates/ruff/resources/test/fixtures/pyflakes/F523.py

@@ -28,6 +28,6 @@
 "{1}{3}".format(1, 2, 3, 4)  # F523, # F524
 "{1} {8}".format(0, 1)  # F523, # F524
 
-# Multiline
+# Not fixable
 (''
 .format(2))

crates/ruff/resources/test/fixtures/pyflakes/F841_3.py

@@ -154,14 +154,3 @@ def f() -> None:
         print("hello")
     except A as e :
         print("oh no!")
-
-
-def f():
-    x = 1
-    y = 2
-
-
-def f():
-    x = 1
-
-    y = 2

crates/ruff/resources/test/fixtures/pylint/bad_string_format_character.py

@@ -16,8 +16,10 @@
 
 "{:*^30s}".format("centered") # OK
 "{:{s}}".format("hello", s="s")  # OK (nested replacement value not checked)
-
 "{:{s:y}}".format("hello", s="s")  # [bad-format-character] (nested replacement format spec checked)
+"{0:.{prec}g}".format(1.23, prec=15)  # OK
+"{0:.{foo}x{bar}y{foobar}g}".format(...)  # OK (all nested replacements are consumed without considering in between chars)
+"{0:.{foo}{bar}{foobar}y}".format(...)  # [bad-format-character] (check value after replacements)
 
 ## f-strings
 

crates/ruff/resources/test/fixtures/pylint/repeated_equality_comparison_target.py

@@ -9,22 +9,13 @@ foo != "a" and foo != "b" and foo != "c"
 
 foo == a or foo == "b" or foo == 3  # Mixed types.
 
+# False negatives (the current implementation doesn't support Yoda conditions).
 "a" == foo or "b" == foo or "c" == foo
 
 "a" != foo and "b" != foo and "c" != foo
 
 "a" == foo or foo == "b" or "c" == foo
 
-foo == bar or baz == foo or qux == foo
-
-foo == "a" or "b" == foo or foo == "c"
-
-foo != "a" and "b" != foo and foo != "c"
-
-foo == "a" or foo == "b" or "c" == bar or "d" == bar  # Multiple targets
-
-foo.bar == "a" or foo.bar == "b"  # Attributes.
-
 # OK
 foo == "a" and foo == "b" and foo == "c"  # `and` mixed with `==`.
 
@@ -45,9 +36,3 @@ foo != "a"  # Single comparison.
 foo == "a" == "b" or foo == "c"  # Multiple comparisons.
 
 foo == bar == "b" or foo == "c"  # Multiple comparisons.
-
-foo == foo or foo == bar  # Self-comparison.
-
-foo[0] == "a" or foo[0] == "b"  # Subscripts.
-
-foo() == "a" or foo() == "b"  # Calls.

crates/ruff/resources/test/fixtures/pyupgrade/UP009_10.py

@@ -1,7 +0,0 @@
-"""
-# coding=utf8""" # empty comment
-
-"""
-Invalid coding declaration since it is nested inside a docstring
-The following empty comment tests for false positives as our implementation visits comments
-"""

crates/ruff/resources/test/fixtures/pyupgrade/UP009_6.py

@@ -1,7 +0,0 @@
- # coding=utf8
-print("Hello world")
-
-"""
-Regression test for https://github.com/astral-sh/ruff/issues/6756
-The leading space must be removed to prevent invalid syntax.
-"""

crates/ruff/resources/test/fixtures/pyupgrade/UP009_7.py

@@ -1,7 +0,0 @@
-	# coding=utf8
-print("Hello world")
-
-"""
-Regression test for https://github.com/astral-sh/ruff/issues/6756
-The leading tab must be removed to prevent invalid syntax.
-"""

crates/ruff/resources/test/fixtures/pyupgrade/UP009_8.py

@@ -1,6 +0,0 @@
-print("foo") # coding=utf8
-print("Hello world")
-
-"""
-Invalid coding declaration due to a statement before the comment
-"""

crates/ruff/resources/test/fixtures/pyupgrade/UP009_9.py

@@ -1,7 +0,0 @@
-x = 1 \
-  # coding=utf8
-x = 2
-
-"""
-Invalid coding declaration due to continuation on preceding line
-"""

crates/ruff/resources/test/fixtures/pyupgrade/UP018.py

@@ -31,7 +31,6 @@ bool("foo")
 bool("")
 bool(b"")
 bool(1.0)
-int().denominator
 
 # These become string or byte literals
 str()
@@ -50,6 +49,3 @@ float(1.0)
 bool()
 bool(True)
 bool(False)
-
-# These become a literal but retain parentheses
-int(1).denominator

crates/ruff/src/autofix/edits.rs

@@ -11,7 +11,7 @@ use ruff_python_trivia::{
     has_leading_content, is_python_whitespace, PythonWhitespace, SimpleTokenKind, SimpleTokenizer,
 };
 use ruff_source_file::{Locator, NewlineWithTrailingNewline};
-use ruff_text_size::{TextLen, TextSize};
+use ruff_text_size::{TextLen, TextRange, TextSize};
 
 use crate::autofix::codemods;
 
@@ -48,7 +48,7 @@ pub(crate) fn delete_stmt(
         } else if has_leading_content(stmt.start(), locator) {
             Edit::range_deletion(stmt.range())
         } else if let Some(start) = indexer.preceded_by_continuations(stmt.start(), locator) {
-            Edit::deletion(start, stmt.end())
+            Edit::range_deletion(TextRange::new(start, stmt.end()))
         } else {
             let range = locator.full_lines_range(stmt.range());
             Edit::range_deletion(range)
@@ -133,8 +133,10 @@ pub(crate) fn remove_argument<T: Ranged>(
         // Case 3: argument or keyword is the only node, so delete the arguments (but preserve
         // parentheses, if needed).
         Ok(match parentheses {
-            Parentheses::Remove => Edit::range_deletion(arguments.range()),
-            Parentheses::Preserve => Edit::range_replacement("()".to_string(), arguments.range()),
+            Parentheses::Remove => Edit::deletion(arguments.start(), arguments.end()),
+            Parentheses::Preserve => {
+                Edit::replacement("()".to_string(), arguments.start(), arguments.end())
+            }
         })
     }
 }
@@ -226,25 +228,25 @@ fn trailing_semicolon(offset: TextSize, locator: &Locator) -> Option<TextSize> {
 fn next_stmt_break(semicolon: TextSize, locator: &Locator) -> TextSize {
     let start_location = semicolon + TextSize::from(1);
 
-    for line in
-        NewlineWithTrailingNewline::with_offset(locator.after(start_location), start_location)
-    {
+    let contents = &locator.contents()[usize::from(start_location)..];
+    for line in NewlineWithTrailingNewline::from(contents) {
         let trimmed = line.trim_whitespace();
         // Skip past any continuations.
         if trimmed.starts_with('\\') {
             continue;
         }
 
-        return if trimmed.is_empty() {
-            // If the line is empty, then despite the previous statement ending in a
-            // semicolon, we know that it's not a multi-statement line.
-            line.start()
-        } else {
-            // Otherwise, find the start of the next statement. (Or, anything that isn't
-            // whitespace.)
-            let relative_offset = line.find(|c: char| !is_python_whitespace(c)).unwrap();
-            line.start() + TextSize::try_from(relative_offset).unwrap()
-        };
+        return start_location
+            + if trimmed.is_empty() {
+                // If the line is empty, then despite the previous statement ending in a
+                // semicolon, we know that it's not a multi-statement line.
+                line.start()
+            } else {
+                // Otherwise, find the start of the next statement. (Or, anything that isn't
+                // whitespace.)
+                let relative_offset = line.find(|c: char| !is_python_whitespace(c)).unwrap();
+                line.start() + TextSize::try_from(relative_offset).unwrap()
+            };
     }
 
     locator.line_end(start_location)

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

@@ -381,34 +381,34 @@ pub(crate) fn expression(expr: &Expr, checker: &mut Checker) {
                                 Ok(summary) => {
                                     if checker.enabled(Rule::StringDotFormatExtraNamedArguments) {
                                         pyflakes::rules::string_dot_format_extra_named_arguments(
-                                            checker, call, &summary, keywords,
+                                            checker, &summary, keywords, location,
                                         );
                                     }
                                     if checker
                                         .enabled(Rule::StringDotFormatExtraPositionalArguments)
                                     {
                                         pyflakes::rules::string_dot_format_extra_positional_arguments(
-                                            checker, call, &summary, args,
+                                            checker, &summary, args, location,
                                         );
                                     }
                                     if checker.enabled(Rule::StringDotFormatMissingArguments) {
                                         pyflakes::rules::string_dot_format_missing_argument(
-                                            checker, call, &summary, args, keywords,
+                                            checker, &summary, args, keywords, location,
                                         );
                                     }
                                     if checker.enabled(Rule::StringDotFormatMixingAutomatic) {
                                         pyflakes::rules::string_dot_format_mixing_automatic(
-                                            checker, call, &summary,
+                                            checker, &summary, location,
                                         );
                                     }
                                     if checker.enabled(Rule::FormatLiterals) {
-                                        pyupgrade::rules::format_literals(checker, call, &summary);
+                                        pyupgrade::rules::format_literals(checker, &summary, call);
                                     }
                                     if checker.enabled(Rule::FString) {
                                         pyupgrade::rules::f_strings(
                                             checker,
-                                            call,
                                             &summary,
+                                            expr,
                                             value,
                                             checker.settings.line_length,
                                         );
@@ -441,11 +441,7 @@ pub(crate) fn expression(expr: &Expr, checker: &mut Checker) {
                 pyupgrade::rules::redundant_open_modes(checker, call);
             }
             if checker.enabled(Rule::NativeLiterals) {
-                pyupgrade::rules::native_literals(
-                    checker,
-                    call,
-                    checker.semantic().current_expression_parent(),
-                );
+                pyupgrade::rules::native_literals(checker, expr, func, args, keywords);
             }
             if checker.enabled(Rule::OpenAlias) {
                 pyupgrade::rules::open_alias(checker, expr, func);

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

@@ -52,8 +52,7 @@ use ruff_python_parser::typing::{parse_type_annotation, AnnotationKind};
 use ruff_python_semantic::analyze::{typing, visibility};
 use ruff_python_semantic::{
     BindingFlags, BindingId, BindingKind, Exceptions, Export, FromImport, Globals, Import, Module,
-    ModuleKind, NodeId, ScopeId, ScopeKind, SemanticModel, SemanticModelFlags, StarImport,
-    SubmoduleImport,
+    ModuleKind, ScopeId, ScopeKind, SemanticModel, SemanticModelFlags, StarImport, SubmoduleImport,
 };
 use ruff_python_stdlib::builtins::{BUILTINS, MAGIC_GLOBALS};
 use ruff_source_file::Locator;
@@ -194,6 +193,24 @@ impl<'a> Checker<'a> {
         }
     }
 
+    /// Returns the [`IsolationLevel`] to isolate fixes for the current statement.
+    ///
+    /// The primary use-case for fix isolation is to ensure that we don't delete all statements
+    /// in a given indented block, which would cause a syntax error. We therefore need to ensure
+    /// that we delete at most one statement per indented block per fixer pass. Fix isolation should
+    /// thus be applied whenever we delete a statement, but can otherwise be omitted.
+    pub(crate) fn statement_isolation(&self) -> IsolationLevel {
+        IsolationLevel::Group(self.semantic.current_statement_id().into())
+    }
+
+    /// Returns the [`IsolationLevel`] to isolate fixes in the current statement's parent.
+    pub(crate) fn parent_isolation(&self) -> IsolationLevel {
+        self.semantic
+            .current_statement_parent_id()
+            .map(|node_id| IsolationLevel::Group(node_id.into()))
+            .unwrap_or_default()
+    }
+
     /// The [`Locator`] for the current file, which enables extraction of source code from byte
     /// offsets.
     pub(crate) const fn locator(&self) -> &'a Locator<'a> {
@@ -242,18 +259,6 @@ impl<'a> Checker<'a> {
     pub(crate) const fn any_enabled(&self, rules: &[Rule]) -> bool {
         self.settings.rules.any_enabled(rules)
     }
-
-    /// Returns the [`IsolationLevel`] to isolate fixes for a given node.
-    ///
-    /// The primary use-case for fix isolation is to ensure that we don't delete all statements
-    /// in a given indented block, which would cause a syntax error. We therefore need to ensure
-    /// that we delete at most one statement per indented block per fixer pass. Fix isolation should
-    /// thus be applied whenever we delete a statement, but can otherwise be omitted.
-    pub(crate) fn isolation(node_id: Option<NodeId>) -> IsolationLevel {
-        node_id
-            .map(|node_id| IsolationLevel::Group(node_id.into()))
-            .unwrap_or_default()
-    }
 }
 
 impl<'a, 'b> Visitor<'b> for Checker<'a>
@@ -1335,46 +1340,23 @@ where
 
     fn visit_pattern(&mut self, pattern: &'b Pattern) {
         // Step 1: Binding
-        match &pattern {
-            Pattern::MatchAs(ast::PatternMatchAs {
-                name: Some(name),
-                pattern: _,
-                range: _,
-            }) => {
-                self.add_binding(
-                    name,
-                    name.range(),
-                    BindingKind::Assignment,
-                    BindingFlags::empty(),
-                );
-            }
-            Pattern::MatchStar(ast::PatternMatchStar {
-                name: Some(name),
-                range: _,
-            }) => {
-                self.add_binding(
-                    name,
-                    name.range(),
-                    BindingKind::Assignment,
-                    BindingFlags::empty(),
-                );
-            }
-            Pattern::MatchMapping(ast::PatternMatchMapping {
-                rest: Some(rest), ..
-            }) => {
-                if let Pattern::MatchAs(ast::PatternMatchAs {
-                    name: Some(name), ..
-                }) = rest.as_ref()
-                {
-                    self.add_binding(
-                        name,
-                        name.range(),
-                        BindingKind::Assignment,
-                        BindingFlags::empty(),
-                    );
-                }
-            }
-            _ => {}
+        if let Pattern::MatchAs(ast::PatternMatchAs {
+            name: Some(name), ..
+        })
+        | Pattern::MatchStar(ast::PatternMatchStar {
+            name: Some(name),
+            range: _,
+        })
+        | Pattern::MatchMapping(ast::PatternMatchMapping {
+            rest: Some(name), ..
+        }) = pattern
+        {
+            self.add_binding(
+                name,
+                name.range(),
+                BindingKind::Assignment,
+                BindingFlags::empty(),
+            );
         }
 
         // Step 2: Traversal

crates/ruff/src/checkers/noqa.rs

@@ -110,8 +110,8 @@ pub(crate) fn check_noqa(
                         let mut diagnostic =
                             Diagnostic::new(UnusedNOQA { codes: None }, directive.range());
                         if settings.rules.should_fix(diagnostic.kind.rule()) {
-                            diagnostic
-                                .set_fix(Fix::automatic(delete_noqa(directive.range(), locator)));
+                            #[allow(deprecated)]
+                            diagnostic.set_fix_from_edit(delete_noqa(directive.range(), locator));
                         }
                         diagnostics.push(diagnostic);
                     }
@@ -175,12 +175,12 @@ pub(crate) fn check_noqa(
                         );
                         if settings.rules.should_fix(diagnostic.kind.rule()) {
                             if valid_codes.is_empty() {
-                                diagnostic.set_fix(Fix::automatic(delete_noqa(
-                                    directive.range(),
-                                    locator,
-                                )));
+                                #[allow(deprecated)]
+                                diagnostic
+                                    .set_fix_from_edit(delete_noqa(directive.range(), locator));
                             } else {
-                                diagnostic.set_fix(Fix::automatic(Edit::range_replacement(
+                                #[allow(deprecated)]
+                                diagnostic.set_fix(Fix::unspecified(Edit::range_replacement(
                                     format!("# noqa: {}", valid_codes.join(", ")),
                                     directive.range(),
                                 )));

crates/ruff/src/cst/matchers.rs

@@ -1,11 +1,9 @@
-use crate::autofix::codemods::CodegenStylist;
 use anyhow::{bail, Result};
 use libcst_native::{
     Arg, Attribute, Call, Comparison, CompoundStatement, Dict, Expression, FunctionDef,
     GeneratorExp, If, Import, ImportAlias, ImportFrom, ImportNames, IndentedBlock, Lambda,
     ListComp, Module, Name, SmallStatement, Statement, Suite, Tuple, With,
 };
-use ruff_python_codegen::Stylist;
 
 pub(crate) fn match_module(module_text: &str) -> Result<Module> {
     match libcst_native::parse_module(module_text, None) {
@@ -14,6 +12,13 @@ pub(crate) fn match_module(module_text: &str) -> Result<Module> {
     }
 }
 
+pub(crate) fn match_expression(expression_text: &str) -> Result<Expression> {
+    match libcst_native::parse_expression(expression_text) {
+        Ok(expression) => Ok(expression),
+        Err(_) => bail!("Failed to extract expression from source"),
+    }
+}
+
 pub(crate) fn match_statement(statement_text: &str) -> Result<Statement> {
     match libcst_native::parse_statement(statement_text) {
         Ok(statement) => Ok(statement),
@@ -200,59 +205,3 @@ pub(crate) fn match_if<'a, 'b>(statement: &'a mut Statement<'b>) -> Result<&'a m
         bail!("Expected Statement::Compound")
     }
 }
-
-/// Given the source code for an expression, return the parsed [`Expression`].
-///
-/// If the expression is not guaranteed to be valid as a standalone expression (e.g., if it may
-/// span multiple lines and/or require parentheses), use [`transform_expression`] instead.
-pub(crate) fn match_expression(expression_text: &str) -> Result<Expression> {
-    match libcst_native::parse_expression(expression_text) {
-        Ok(expression) => Ok(expression),
-        Err(_) => bail!("Failed to extract expression from source"),
-    }
-}
-
-/// Run a transformation function over an expression.
-///
-/// Passing an expression to [`match_expression`] directly can lead to parse errors if the
-/// expression is not a valid standalone expression (e.g., it was parenthesized in the original
-/// source). This method instead wraps the expression in "fake" parentheses, runs the
-/// transformation, then removes the "fake" parentheses.
-pub(crate) fn transform_expression(
-    source_code: &str,
-    stylist: &Stylist,
-    func: impl FnOnce(Expression) -> Result<Expression>,
-) -> Result<String> {
-    // Wrap the expression in parentheses.
-    let source_code = format!("({source_code})");
-    let expression = match_expression(&source_code)?;
-
-    // Run the function on the expression.
-    let expression = func(expression)?;
-
-    // Codegen the expression.
-    let mut source_code = expression.codegen_stylist(stylist);
-
-    // Drop the outer parentheses.
-    source_code.drain(0..1);
-    source_code.drain(source_code.len() - 1..source_code.len());
-    Ok(source_code)
-}
-
-/// Like [`transform_expression`], but operates on the source code of the expression, rather than
-/// the parsed [`Expression`]. This _shouldn't_ exist, but does to accommodate lifetime issues.
-pub(crate) fn transform_expression_text(
-    source_code: &str,
-    func: impl FnOnce(String) -> Result<String>,
-) -> Result<String> {
-    // Wrap the expression in parentheses.
-    let source_code = format!("({source_code})");
-
-    // Run the function on the expression.
-    let mut transformed = func(source_code)?;
-
-    // Drop the outer parentheses.
-    transformed.drain(0..1);
-    transformed.drain(transformed.len() - 1..transformed.len());
-    Ok(transformed)
-}

crates/ruff/src/noqa.rs

@@ -562,7 +562,7 @@ fn add_noqa_inner(
     let mut prev_end = TextSize::default();
 
     for (offset, (rules, directive)) in matches_by_line {
-        output.push_str(locator.slice(TextRange::new(prev_end, offset)));
+        output.push_str(&locator.contents()[TextRange::new(prev_end, offset)]);
 
         let line = locator.full_line(offset);
 
@@ -619,7 +619,7 @@ fn add_noqa_inner(
         prev_end = offset + line.text_len();
     }
 
-    output.push_str(locator.after(prev_end));
+    output.push_str(&locator.contents()[usize::from(prev_end)..]);
 
     (count, output)
 }

crates/ruff/src/rules/flake8_annotations/fixes.rs

@@ -0,0 +1,45 @@
+use anyhow::{bail, Result};
+use ruff_python_ast::{PySourceType, Ranged};
+use ruff_python_parser::{lexer, AsMode, Tok};
+
+use ruff_diagnostics::Edit;
+use ruff_source_file::Locator;
+
+/// ANN204
+pub(crate) fn add_return_annotation<T: Ranged>(
+    statement: &T,
+    annotation: &str,
+    source_type: PySourceType,
+    locator: &Locator,
+) -> Result<Edit> {
+    let contents = &locator.contents()[statement.range()];
+
+    // Find the colon (following the `def` keyword).
+    let mut seen_lpar = false;
+    let mut seen_rpar = false;
+    let mut count = 0u32;
+    for (tok, range) in
+        lexer::lex_starts_at(contents, source_type.as_mode(), statement.start()).flatten()
+    {
+        if seen_lpar && seen_rpar {
+            if matches!(tok, Tok::Colon) {
+                return Ok(Edit::insertion(format!(" -> {annotation}"), range.start()));
+            }
+        }
+
+        if matches!(tok, Tok::Lpar) {
+            if count == 0 {
+                seen_lpar = true;
+            }
+            count = count.saturating_add(1);
+        }
+        if matches!(tok, Tok::Rpar) {
+            count = count.saturating_sub(1);
+            if count == 0 {
+                seen_rpar = true;
+            }
+        }
+    }
+
+    bail!("Unable to locate colon in function definition");
+}

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

@@ -1,4 +1,5 @@
 //! Rules from [flake8-annotations](https://pypi.org/project/flake8-annotations/).
+mod fixes;
 pub(crate) mod helpers;
 pub(crate) mod rules;
 pub mod settings;

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

@@ -1,4 +1,4 @@
-use ruff_diagnostics::{AlwaysAutofixableViolation, Diagnostic, Edit, Fix, Violation};
+use ruff_diagnostics::{AlwaysAutofixableViolation, Diagnostic, Fix, Violation};
 use ruff_macros::{derive_message_formats, violation};
 use ruff_python_ast::helpers::ReturnStatementVisitor;
 use ruff_python_ast::identifier::Identifier;
@@ -11,6 +11,7 @@ use ruff_python_stdlib::typing::simple_magic_return_type;
 
 use crate::checkers::ast::Checker;
 use crate::registry::{AsRule, Rule};
+use crate::rules::flake8_annotations::fixes;
 use crate::rules::ruff::typing::type_hint_resolves_to_any;
 
 /// ## What it does
@@ -703,10 +704,15 @@ pub(crate) fn definition(
                         function.identifier(),
                     );
                     if checker.patch(diagnostic.kind.rule()) {
-                        diagnostic.set_fix(Fix::suggested(Edit::insertion(
-                            " -> None".to_string(),
-                            function.parameters.range().end(),
-                        )));
+                        diagnostic.try_set_fix(|| {
+                            fixes::add_return_annotation(
+                                function,
+                                "None",
+                                checker.source_type,
+                                checker.locator(),
+                            )
+                            .map(Fix::suggested)
+                        });
                     }
                     diagnostics.push(diagnostic);
                 }
@@ -721,10 +727,15 @@ pub(crate) fn definition(
                 );
                 if checker.patch(diagnostic.kind.rule()) {
                     if let Some(return_type) = simple_magic_return_type(name) {
-                        diagnostic.set_fix(Fix::suggested(Edit::insertion(
-                            format!(" -> {return_type}"),
-                            function.parameters.range().end(),
-                        )));
+                        diagnostic.try_set_fix(|| {
+                            fixes::add_return_annotation(
+                                function,
+                                return_type,
+                                checker.source_type,
+                                checker.locator(),
+                            )
+                            .map(Fix::suggested)
+                        });
                     }
                 }
                 diagnostics.push(diagnostic);

crates/ruff/src/rules/flake8_annotations/snapshots/ruff__rules__flake8_annotations__tests__defaults.snap

@@ -242,22 +242,4 @@ annotation_presence.py:154:10: ANN401 Dynamically typed expressions (typing.Any)
     |          ^^^^^^^^^^^^^^^^^^^^^^^^ ANN401
     |
 
-annotation_presence.py:159:9: ANN204 [*] Missing return type annotation for special method `__init__`
-    |
-157 | class Foo:
-158 |     @decorator()
-159 |     def __init__(self: "Foo", foo: int):
-    |         ^^^^^^^^ ANN204
-160 |        ...
-    |
-    = help: Add `None` return type
-
-ℹ Suggested fix
-156 156 | 
-157 157 | class Foo:
-158 158 |     @decorator()
-159     |-    def __init__(self: "Foo", foo: int):
-    159 |+    def __init__(self: "Foo", foo: int) -> None:
-160 160 |        ...
-
 

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

@@ -71,27 +71,8 @@ mod tests {
     }
 
     #[test]
-    fn extend_immutable_calls_arg_annotation() -> Result<()> {
-        let snapshot = "extend_immutable_calls_arg_annotation".to_string();
-        let diagnostics = test_path(
-            Path::new("flake8_bugbear/B006_extended.py"),
-            &Settings {
-                flake8_bugbear: super::settings::Settings {
-                    extend_immutable_calls: vec![
-                        "custom.ImmutableTypeA".to_string(),
-                        "custom.ImmutableTypeB".to_string(),
-                    ],
-                },
-                ..Settings::for_rule(Rule::MutableArgumentDefault)
-            },
-        )?;
-        assert_messages!(snapshot, diagnostics);
-        Ok(())
-    }
-
-    #[test]
-    fn extend_immutable_calls_arg_default() -> Result<()> {
-        let snapshot = "extend_immutable_calls_arg_default".to_string();
+    fn extend_immutable_calls() -> Result<()> {
+        let snapshot = "extend_immutable_calls".to_string();
         let diagnostics = test_path(
             Path::new("flake8_bugbear/B008_extended.py"),
             &Settings {

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

@@ -1,4 +1,3 @@
-use ast::call_path::{from_qualified_name, CallPath};
 use ruff_diagnostics::{AutofixKind, Diagnostic, Edit, Fix, Violation};
 use ruff_macros::{derive_message_formats, violation};
 use ruff_python_ast::helpers::is_docstring_stmt;
@@ -26,10 +25,6 @@ use crate::registry::AsRule;
 /// default, and initialize a new mutable object inside the function body
 /// for each call.
 ///
-/// Arguments with immutable type annotations will be ignored by this rule.
-/// Types outside of the standard library can be marked as immutable with the
-/// [`flake8-bugbear.extend-immutable-calls`] configuration option.
-///
 /// ## Example
 /// ```python
 /// def add_to_list(item, some_list=[]):
@@ -54,9 +49,6 @@ use crate::registry::AsRule;
 /// l2 = add_to_list(1)  # [1]
 /// ```
 ///
-/// ## Options
-/// - `flake8-bugbear.extend-immutable-calls`
-///
 /// ## References
 /// - [Python documentation: Default Argument Values](https://docs.python.org/3/tutorial/controlflow.html#default-argument-values)
 #[violation]
@@ -92,18 +84,11 @@ pub(crate) fn mutable_argument_default(checker: &mut Checker, function_def: &ast
             continue;
         };
 
-        let extend_immutable_calls: Vec<CallPath> = checker
-            .settings
-            .flake8_bugbear
-            .extend_immutable_calls
-            .iter()
-            .map(|target| from_qualified_name(target))
-            .collect();
-
         if is_mutable_expr(default, checker.semantic())
-            && !parameter.annotation.as_ref().is_some_and(|expr| {
-                is_immutable_annotation(expr, checker.semantic(), extend_immutable_calls.as_slice())
-            })
+            && !parameter
+                .annotation
+                .as_ref()
+                .is_some_and(|expr| is_immutable_annotation(expr, checker.semantic()))
         {
             let mut diagnostic = Diagnostic::new(MutableArgumentDefault, default.range());
 
@@ -140,7 +125,7 @@ fn move_initialization(
     let mut body = function_def.body.iter();
 
     let statement = body.next()?;
-    if indexer.in_multi_statement_line(statement, locator) {
+    if indexer.preceded_by_multi_statement_line(statement, locator) {
         return None;
     }
 
@@ -170,7 +155,7 @@ fn move_initialization(
         if let Some(statement) = body.next() {
             // If there's a second statement, insert _before_ it, but ensure this isn't a
             // multi-statement line.
-            if indexer.in_multi_statement_line(statement, locator) {
+            if indexer.preceded_by_multi_statement_line(statement, locator) {
                 return None;
             }
             Edit::insertion(content, locator.line_start(statement.start()))

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

@@ -79,6 +79,7 @@ pub(crate) fn redundant_tuple_in_exception_handler(
             type_.range(),
         );
         if checker.patch(diagnostic.kind.rule()) {
+            #[allow(deprecated)]
             diagnostic.set_fix(Fix::automatic(Edit::range_replacement(
                 checker.generator().expr(elt),
                 type_.range(),

crates/ruff/src/rules/flake8_bugbear/snapshots/ruff__rules__flake8_bugbear__tests__extend_immutable_calls_arg_annotation.snap

@@ -1,22 +0,0 @@
----
-source: crates/ruff/src/rules/flake8_bugbear/mod.rs
----
-B006_extended.py:17:55: B006 [*] Do not use mutable data structures for argument defaults
-   |
-17 | def error_due_to_missing_import(foo: ImmutableTypeA = []):
-   |                                                       ^^ B006
-18 |     ...
-   |
-   = help: Replace with `None`; initialize within function
-
-ℹ Possible fix
-14 14 |     ...
-15 15 | 
-16 16 | 
-17    |-def error_due_to_missing_import(foo: ImmutableTypeA = []):
-   17 |+def error_due_to_missing_import(foo: ImmutableTypeA = None):
-   18 |+    if foo is None:
-   19 |+        foo = []
-18 20 |     ...
-
-

crates/ruff/src/rules/flake8_comprehensions/rules/unnecessary_collection_call.rs

@@ -1,4 +1,4 @@
-use ruff_diagnostics::{AlwaysAutofixableViolation, Diagnostic, Fix};
+use ruff_diagnostics::{AlwaysAutofixableViolation, Diagnostic};
 use ruff_macros::{derive_message_formats, violation};
 use ruff_python_ast::{Expr, Keyword, Ranged};
 
@@ -86,9 +86,8 @@ pub(crate) fn unnecessary_collection_call(
         expr.range(),
     );
     if checker.patch(diagnostic.kind.rule()) {
-        diagnostic.try_set_fix(|| {
-            fixes::fix_unnecessary_collection_call(checker, expr).map(Fix::suggested)
-        });
+        #[allow(deprecated)]
+        diagnostic.try_set_fix_from_edit(|| fixes::fix_unnecessary_collection_call(checker, expr));
     }
     checker.diagnostics.push(diagnostic);
 }

crates/ruff/src/rules/flake8_comprehensions/rules/unnecessary_comprehension.rs

@@ -1,4 +1,4 @@
-use ruff_diagnostics::{AlwaysAutofixableViolation, Diagnostic, Fix};
+use ruff_diagnostics::{AlwaysAutofixableViolation, Diagnostic};
 use ruff_macros::{derive_message_formats, violation};
 use ruff_python_ast::{self as ast, Comprehension, Expr, Ranged};
 
@@ -63,9 +63,9 @@ fn add_diagnostic(checker: &mut Checker, expr: &Expr) {
         expr.range(),
     );
     if checker.patch(diagnostic.kind.rule()) {
-        diagnostic.try_set_fix(|| {
+        #[allow(deprecated)]
+        diagnostic.try_set_fix_from_edit(|| {
             fixes::fix_unnecessary_comprehension(checker.locator(), checker.stylist(), expr)
-                .map(Fix::suggested)
         });
     }
     checker.diagnostics.push(diagnostic);

crates/ruff/src/rules/flake8_comprehensions/rules/unnecessary_double_cast_or_process.rs

@@ -1,4 +1,4 @@
-use ruff_diagnostics::{AlwaysAutofixableViolation, Diagnostic, Fix};
+use ruff_diagnostics::{AlwaysAutofixableViolation, Diagnostic};
 use ruff_macros::{derive_message_formats, violation};
 use ruff_python_ast::comparable::ComparableKeyword;
 use ruff_python_ast::{self as ast, Arguments, Expr, Keyword, Ranged};
@@ -130,13 +130,13 @@ pub(crate) fn unnecessary_double_cast_or_process(
             expr.range(),
         );
         if checker.patch(diagnostic.kind.rule()) {
-            diagnostic.try_set_fix(|| {
+            #[allow(deprecated)]
+            diagnostic.try_set_fix_from_edit(|| {
                 fixes::fix_unnecessary_double_cast_or_process(
                     checker.locator(),
                     checker.stylist(),
                     expr,
                 )
-                .map(Fix::suggested)
             });
         }
         checker.diagnostics.push(diagnostic);

crates/ruff/src/rules/flake8_comprehensions/rules/unnecessary_generator_dict.rs

@@ -1,7 +1,8 @@
-use ruff_diagnostics::{AlwaysAutofixableViolation, Diagnostic, Fix};
-use ruff_macros::{derive_message_formats, violation};
 use ruff_python_ast::{self as ast, Expr, Keyword, Ranged};
 
+use ruff_diagnostics::{AlwaysAutofixableViolation, Diagnostic};
+use ruff_macros::{derive_message_formats, violation};
+
 use crate::checkers::ast::Checker;
 use crate::registry::AsRule;
 use crate::rules::flake8_comprehensions::fixes;
@@ -58,8 +59,9 @@ pub(crate) fn unnecessary_generator_dict(
             Expr::Tuple(ast::ExprTuple { elts, .. }) if elts.len() == 2 => {
                 let mut diagnostic = Diagnostic::new(UnnecessaryGeneratorDict, expr.range());
                 if checker.patch(diagnostic.kind.rule()) {
-                    diagnostic.try_set_fix(|| {
-                        fixes::fix_unnecessary_generator_dict(checker, expr).map(Fix::suggested)
+                    #[allow(deprecated)]
+                    diagnostic.try_set_fix_from_edit(|| {
+                        fixes::fix_unnecessary_generator_dict(checker, expr)
                     });
                 }
                 checker.diagnostics.push(diagnostic);

crates/ruff/src/rules/flake8_comprehensions/rules/unnecessary_generator_list.rs

@@ -1,6 +1,6 @@
 use ruff_python_ast::{Expr, Keyword, Ranged};
 
-use ruff_diagnostics::{AlwaysAutofixableViolation, Diagnostic, Fix};
+use ruff_diagnostics::{AlwaysAutofixableViolation, Diagnostic};
 use ruff_macros::{derive_message_formats, violation};
 
 use crate::checkers::ast::Checker;
@@ -60,9 +60,9 @@ pub(crate) fn unnecessary_generator_list(
     if let Expr::GeneratorExp(_) = argument {
         let mut diagnostic = Diagnostic::new(UnnecessaryGeneratorList, expr.range());
         if checker.patch(diagnostic.kind.rule()) {
-            diagnostic.try_set_fix(|| {
+            #[allow(deprecated)]
+            diagnostic.try_set_fix_from_edit(|| {
                 fixes::fix_unnecessary_generator_list(checker.locator(), checker.stylist(), expr)
-                    .map(Fix::suggested)
             });
         }
         checker.diagnostics.push(diagnostic);

crates/ruff/src/rules/flake8_comprehensions/rules/unnecessary_generator_set.rs

@@ -1,6 +1,6 @@
 use ruff_python_ast::{Expr, Keyword, Ranged};
 
-use ruff_diagnostics::{AlwaysAutofixableViolation, Diagnostic, Fix};
+use ruff_diagnostics::{AlwaysAutofixableViolation, Diagnostic};
 use ruff_macros::{derive_message_formats, violation};
 
 use crate::checkers::ast::Checker;
@@ -60,9 +60,9 @@ pub(crate) fn unnecessary_generator_set(
     if let Expr::GeneratorExp(_) = argument {
         let mut diagnostic = Diagnostic::new(UnnecessaryGeneratorSet, expr.range());
         if checker.patch(diagnostic.kind.rule()) {
-            diagnostic.try_set_fix(|| {
-                fixes::fix_unnecessary_generator_set(checker, expr).map(Fix::suggested)
-            });
+            #[allow(deprecated)]
+            diagnostic
+                .try_set_fix_from_edit(|| fixes::fix_unnecessary_generator_set(checker, expr));
         }
         checker.diagnostics.push(diagnostic);
     }

crates/ruff/src/rules/flake8_comprehensions/rules/unnecessary_list_call.rs

@@ -1,6 +1,6 @@
 use ruff_python_ast::{Expr, Ranged};
 
-use ruff_diagnostics::{AlwaysAutofixableViolation, Diagnostic, Fix};
+use ruff_diagnostics::{AlwaysAutofixableViolation, Diagnostic};
 use ruff_macros::{derive_message_formats, violation};
 
 use crate::checkers::ast::Checker;
@@ -56,9 +56,9 @@ pub(crate) fn unnecessary_list_call(
     }
     let mut diagnostic = Diagnostic::new(UnnecessaryListCall, expr.range());
     if checker.patch(diagnostic.kind.rule()) {
-        diagnostic.try_set_fix(|| {
+        #[allow(deprecated)]
+        diagnostic.try_set_fix_from_edit(|| {
             fixes::fix_unnecessary_list_call(checker.locator(), checker.stylist(), expr)
-                .map(Fix::suggested)
         });
     }
     checker.diagnostics.push(diagnostic);

crates/ruff/src/rules/flake8_comprehensions/rules/unnecessary_list_comprehension_dict.rs

@@ -1,7 +1,8 @@
-use ruff_diagnostics::{AlwaysAutofixableViolation, Diagnostic, Fix};
-use ruff_macros::{derive_message_formats, violation};
 use ruff_python_ast::{self as ast, Expr, Keyword, Ranged};
 
+use ruff_diagnostics::{AlwaysAutofixableViolation, Diagnostic};
+use ruff_macros::{derive_message_formats, violation};
+
 use crate::checkers::ast::Checker;
 use crate::registry::AsRule;
 use crate::rules::flake8_comprehensions::fixes;
@@ -65,8 +66,9 @@ pub(crate) fn unnecessary_list_comprehension_dict(
     }
     let mut diagnostic = Diagnostic::new(UnnecessaryListComprehensionDict, expr.range());
     if checker.patch(diagnostic.kind.rule()) {
-        diagnostic.try_set_fix(|| {
-            fixes::fix_unnecessary_list_comprehension_dict(checker, expr).map(Fix::suggested)
+        #[allow(deprecated)]
+        diagnostic.try_set_fix_from_edit(|| {
+            fixes::fix_unnecessary_list_comprehension_dict(checker, expr)
         });
     }
     checker.diagnostics.push(diagnostic);

crates/ruff/src/rules/flake8_comprehensions/rules/unnecessary_list_comprehension_set.rs

@@ -1,6 +1,6 @@
 use ruff_python_ast::{Expr, Keyword, Ranged};
 
-use ruff_diagnostics::{AlwaysAutofixableViolation, Diagnostic, Fix};
+use ruff_diagnostics::{AlwaysAutofixableViolation, Diagnostic};
 use ruff_macros::{derive_message_formats, violation};
 
 use crate::checkers::ast::Checker;
@@ -58,8 +58,9 @@ pub(crate) fn unnecessary_list_comprehension_set(
     if argument.is_list_comp_expr() {
         let mut diagnostic = Diagnostic::new(UnnecessaryListComprehensionSet, expr.range());
         if checker.patch(diagnostic.kind.rule()) {
-            diagnostic.try_set_fix(|| {
-                fixes::fix_unnecessary_list_comprehension_set(checker, expr).map(Fix::suggested)
+            #[allow(deprecated)]
+            diagnostic.try_set_fix_from_edit(|| {
+                fixes::fix_unnecessary_list_comprehension_set(checker, expr)
             });
         }
         checker.diagnostics.push(diagnostic);

crates/ruff/src/rules/flake8_comprehensions/rules/unnecessary_literal_dict.rs

@@ -1,7 +1,8 @@
-use ruff_diagnostics::{AlwaysAutofixableViolation, Diagnostic, Fix};
-use ruff_macros::{derive_message_formats, violation};
 use ruff_python_ast::{self as ast, Expr, Keyword, Ranged};
 
+use ruff_diagnostics::{AlwaysAutofixableViolation, Diagnostic};
+use ruff_macros::{derive_message_formats, violation};
+
 use crate::checkers::ast::Checker;
 use crate::registry::AsRule;
 use crate::rules::flake8_comprehensions::fixes;
@@ -80,8 +81,8 @@ pub(crate) fn unnecessary_literal_dict(
         expr.range(),
     );
     if checker.patch(diagnostic.kind.rule()) {
-        diagnostic
-            .try_set_fix(|| fixes::fix_unnecessary_literal_dict(checker, expr).map(Fix::suggested));
+        #[allow(deprecated)]
+        diagnostic.try_set_fix_from_edit(|| fixes::fix_unnecessary_literal_dict(checker, expr));
     }
     checker.diagnostics.push(diagnostic);
 }

crates/ruff/src/rules/flake8_comprehensions/rules/unnecessary_literal_set.rs

@@ -1,6 +1,6 @@
 use ruff_python_ast::{Expr, Keyword, Ranged};
 
-use ruff_diagnostics::{AlwaysAutofixableViolation, Diagnostic, Fix};
+use ruff_diagnostics::{AlwaysAutofixableViolation, Diagnostic};
 use ruff_macros::{derive_message_formats, violation};
 
 use crate::checkers::ast::Checker;
@@ -75,8 +75,8 @@ pub(crate) fn unnecessary_literal_set(
         expr.range(),
     );
     if checker.patch(diagnostic.kind.rule()) {
-        diagnostic
-            .try_set_fix(|| fixes::fix_unnecessary_literal_set(checker, expr).map(Fix::suggested));
+        #[allow(deprecated)]
+        diagnostic.try_set_fix_from_edit(|| fixes::fix_unnecessary_literal_set(checker, expr));
     }
     checker.diagnostics.push(diagnostic);
 }

crates/ruff/src/rules/flake8_comprehensions/rules/unnecessary_literal_within_dict_call.rs

@@ -2,7 +2,7 @@ use std::fmt;
 
 use ruff_python_ast::{Expr, Keyword, Ranged};
 
-use ruff_diagnostics::{AlwaysAutofixableViolation, Diagnostic, Fix};
+use ruff_diagnostics::{AlwaysAutofixableViolation, Diagnostic};
 use ruff_macros::{derive_message_formats, violation};
 
 use crate::checkers::ast::Checker;
@@ -91,13 +91,13 @@ pub(crate) fn unnecessary_literal_within_dict_call(
         expr.range(),
     );
     if checker.patch(diagnostic.kind.rule()) {
-        diagnostic.try_set_fix(|| {
+        #[allow(deprecated)]
+        diagnostic.try_set_fix_from_edit(|| {
             fixes::fix_unnecessary_literal_within_dict_call(
                 checker.locator(),
                 checker.stylist(),
                 expr,
             )
-            .map(Fix::suggested)
         });
     }
     checker.diagnostics.push(diagnostic);

crates/ruff/src/rules/flake8_comprehensions/rules/unnecessary_literal_within_list_call.rs

@@ -1,7 +1,8 @@
-use ruff_diagnostics::{AlwaysAutofixableViolation, Diagnostic, Fix};
-use ruff_macros::{derive_message_formats, violation};
 use ruff_python_ast::{Expr, Keyword, Ranged};
 
+use ruff_diagnostics::{AlwaysAutofixableViolation, Diagnostic};
+use ruff_macros::{derive_message_formats, violation};
+
 use crate::checkers::ast::Checker;
 use crate::registry::AsRule;
 use crate::rules::flake8_comprehensions::fixes;
@@ -93,13 +94,13 @@ pub(crate) fn unnecessary_literal_within_list_call(
         expr.range(),
     );
     if checker.patch(diagnostic.kind.rule()) {
-        diagnostic.try_set_fix(|| {
+        #[allow(deprecated)]
+        diagnostic.try_set_fix_from_edit(|| {
             fixes::fix_unnecessary_literal_within_list_call(
                 checker.locator(),
                 checker.stylist(),
                 expr,
             )
-            .map(Fix::suggested)
         });
     }
     checker.diagnostics.push(diagnostic);

crates/ruff/src/rules/flake8_comprehensions/rules/unnecessary_literal_within_tuple_call.rs

@@ -1,6 +1,6 @@
 use ruff_python_ast::{Expr, Keyword, Ranged};
 
-use ruff_diagnostics::{AlwaysAutofixableViolation, Diagnostic, Fix};
+use ruff_diagnostics::{AlwaysAutofixableViolation, Diagnostic};
 use ruff_macros::{derive_message_formats, violation};
 
 use crate::checkers::ast::Checker;
@@ -95,13 +95,13 @@ pub(crate) fn unnecessary_literal_within_tuple_call(
         expr.range(),
     );
     if checker.patch(diagnostic.kind.rule()) {
-        diagnostic.try_set_fix(|| {
+        #[allow(deprecated)]
+        diagnostic.try_set_fix_from_edit(|| {
             fixes::fix_unnecessary_literal_within_tuple_call(
                 checker.locator(),
                 checker.stylist(),
                 expr,
             )
-            .map(Fix::suggested)
         });
     }
     checker.diagnostics.push(diagnostic);

crates/ruff/src/rules/flake8_comprehensions/rules/unnecessary_map.rs

@@ -103,17 +103,10 @@ pub(crate) fn unnecessary_map(
                 return;
             };
 
-            if parameters.as_ref().is_some_and(|parameters| {
-                late_binding(parameters, body)
-                    || parameters
-                        .posonlyargs
-                        .iter()
-                        .chain(&parameters.args)
-                        .chain(&parameters.kwonlyargs)
-                        .any(|param| param.default.is_some())
-                    || parameters.vararg.is_some()
-                    || parameters.kwarg.is_some()
-            }) {
+            if parameters
+                .as_ref()
+                .is_some_and(|parameters| late_binding(parameters, body))
+            {
                 return;
             }
         }
@@ -144,17 +137,10 @@ pub(crate) fn unnecessary_map(
                 return;
             };
 
-            if parameters.as_ref().is_some_and(|parameters| {
-                late_binding(parameters, body)
-                    || parameters
-                        .posonlyargs
-                        .iter()
-                        .chain(&parameters.args)
-                        .chain(&parameters.kwonlyargs)
-                        .any(|param| param.default.is_some())
-                    || parameters.vararg.is_some()
-                    || parameters.kwarg.is_some()
-            }) {
+            if parameters
+                .as_ref()
+                .is_some_and(|parameters| late_binding(parameters, body))
+            {
                 return;
             }
         }
@@ -191,21 +177,14 @@ pub(crate) fn unnecessary_map(
                 return;
             }
 
-            if parameters.as_ref().is_some_and(|parameters| {
-                late_binding(parameters, body)
-                    || parameters
-                        .posonlyargs
-                        .iter()
-                        .chain(&parameters.args)
-                        .chain(&parameters.kwonlyargs)
-                        .any(|param| param.default.is_some())
-                    || parameters.vararg.is_some()
-                    || parameters.kwarg.is_some()
-            }) {
+            if parameters
+                .as_ref()
+                .is_some_and(|parameters| late_binding(parameters, body))
+            {
                 return;
             }
         }
-    };
+    }
 
     let mut diagnostic = Diagnostic::new(UnnecessaryMap { object_type }, expr.range());
     if checker.patch(diagnostic.kind.rule()) {

crates/ruff/src/rules/flake8_comprehensions/snapshots/ruff__rules__flake8_comprehensions__tests__C417_C417.py.snap

@@ -226,7 +226,7 @@ C417.py:15:8: C417 [*] Unnecessary `map` usage (rewrite using a `set` comprehens
    15 |+_ = f"{ {x % 2 == 0 for x in nums} }"
 16 16 | _ = f"{dict(map(lambda v: (v, v**2), nums))}"
 17 17 | 
-18 18 | # False negatives.
+18 18 | # Error, but unfixable.
 
 C417.py:16:8: C417 [*] Unnecessary `map` usage (rewrite using a `dict` comprehension)
    |
@@ -235,7 +235,7 @@ C417.py:16:8: C417 [*] Unnecessary `map` usage (rewrite using a `dict` comprehen
 16 | _ = f"{dict(map(lambda v: (v, v**2), nums))}"
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ C417
 17 | 
-18 | # False negatives.
+18 | # Error, but unfixable.
    |
    = help: Replace `map` with a `dict` comprehension
 
@@ -246,27 +246,33 @@ C417.py:16:8: C417 [*] Unnecessary `map` usage (rewrite using a `dict` comprehen
 16    |-_ = f"{dict(map(lambda v: (v, v**2), nums))}"
    16 |+_ = f"{ {v: v**2 for v in nums} }"
 17 17 | 
-18 18 | # False negatives.
-19 19 | map(lambda x=2, y=1: x + y, nums, nums)
+18 18 | # Error, but unfixable.
+19 19 | # For simple expressions, this could be: `(x if x else 1 for x in nums)`.
 
-C417.py:34:1: C417 [*] Unnecessary `map` usage (rewrite using a generator expression)
+C417.py:21:1: C417 Unnecessary `map` usage (rewrite using a generator expression)
    |
-33 | # Error: the `x` is overridden by the inner lambda.
-34 | map(lambda x: lambda x: x, range(4))
+19 | # For simple expressions, this could be: `(x if x else 1 for x in nums)`.
+20 | # For more complex expressions, this would differ: `(x + 2 if x else 3 for x in nums)`.
+21 | map(lambda x=1: x, nums)
+   | ^^^^^^^^^^^^^^^^^^^^^^^^ C417
+22 | 
+23 | # False negatives.
+   |
+   = help: Replace `map` with a generator expression
+
+C417.py:39:1: C417 [*] Unnecessary `map` usage (rewrite using a generator expression)
+   |
+38 | # Error: the `x` is overridden by the inner lambda.
+39 | map(lambda x: lambda x: x, range(4))
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ C417
-35 | 
-36 | # Ok because of the default parameters, and variadic arguments.
    |
    = help: Replace `map` with a generator expression
 
 ℹ Suggested fix
-31 31 | map(lambda x: lambda: x, range(4))
-32 32 | 
-33 33 | # Error: the `x` is overridden by the inner lambda.
-34    |-map(lambda x: lambda x: x, range(4))
-   34 |+(lambda x: x for x in range(4))
-35 35 | 
-36 36 | # Ok because of the default parameters, and variadic arguments.
-37 37 | map(lambda x=1: x, nums)
+36 36 | map(lambda x: lambda: x, range(4))
+37 37 | 
+38 38 | # Error: the `x` is overridden by the inner lambda.
+39    |-map(lambda x: lambda x: x, range(4))
+   39 |+(lambda x: x for x in range(4))
 
 

crates/ruff/src/rules/flake8_datetimez/rules/call_datetime_strptime_without_zone.rs

@@ -5,49 +5,6 @@ use ruff_python_ast::{self as ast, Constant, Expr, Ranged};
 use crate::checkers::ast::Checker;
 use crate::rules::flake8_datetimez::rules::helpers::has_non_none_keyword;
 
-/// ## What it does
-/// Checks for uses of `datetime.datetime.strptime()` that lead to naive
-/// datetime objects.
-///
-/// ## Why is this bad?
-/// Python datetime objects can be naive or timezone-aware. While an aware
-/// object represents a specific moment in time, a naive object does not
-/// contain enough information to unambiguously locate itself relative to other
-/// datetime objects. Since this can lead to errors, it is recommended to
-/// always use timezone-aware objects.
-///
-/// `datetime.datetime.strptime()` without `%z` returns a naive datetime
-/// object. Follow it with `.replace(tzinfo=)` or `.astimezone()`.
-///
-/// ## Example
-/// ```python
-/// import datetime
-///
-/// datetime.datetime.strptime("2022/01/31", "%Y/%m/%d")
-/// ```
-///
-/// Instead, use `.replace(tzinfo=)`:
-/// ```python
-/// import datetime
-///
-/// datetime.datetime.strptime("2022/01/31", "%Y/%m/%d").replace(
-///     tzinfo=datetime.timezone.utc
-/// )
-/// ```
-///
-/// Or, use `.astimezone()`:
-/// ```python
-/// import datetime
-///
-/// datetime.datetime.strptime("2022/01/31", "%Y/%m/%d").astimezone(datetime.timezone.utc)
-/// ```
-///
-/// On Python 3.11 and later, `datetime.timezone.utc` can be replaced with
-/// `datetime.UTC`.
-///
-/// ## References
-/// - [Python documentation: Aware and Naive Objects](https://docs.python.org/3/library/datetime.html#aware-and-naive-objects)
-/// - [Python documentation: `strftime()` and `strptime()` Behavior](https://docs.python.org/3/library/datetime.html#strftime-and-strptime-behavior)
 #[violation]
 pub struct CallDatetimeStrptimeWithoutZone;
 

crates/ruff/src/rules/flake8_implicit_str_concat/rules/implicit.rs

@@ -126,8 +126,8 @@ pub(crate) fn implicit(
 }
 
 fn concatenate_strings(a_range: TextRange, b_range: TextRange, locator: &Locator) -> Option<Fix> {
-    let a_text = locator.slice(a_range);
-    let b_text = locator.slice(b_range);
+    let a_text = &locator.contents()[a_range];
+    let b_text = &locator.contents()[b_range];
 
     let a_leading_quote = leading_quote(a_text)?;
     let b_leading_quote = leading_quote(b_text)?;

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

@@ -9,7 +9,6 @@ const CONVENTIONAL_ALIASES: &[(&str, &str)] = &[
     ("altair", "alt"),
     ("matplotlib", "mpl"),
     ("matplotlib.pyplot", "plt"),
-    ("networkx", "nx"),
     ("numpy", "np"),
     ("pandas", "pd"),
     ("seaborn", "sns"),

crates/ruff/src/rules/flake8_import_conventions/snapshots/ruff__rules__flake8_import_conventions__tests__defaults.snap

@@ -72,7 +72,7 @@ defaults.py:9:12: ICN001 [*] `pandas` should be imported as `pd`
    9  |+    import pandas as pd
 10 10 |     import seaborn
 11 11 |     import tkinter
-12 12 |     import networkx
+12 12 | 
 
 defaults.py:10:12: ICN001 [*] `seaborn` should be imported as `sns`
    |
@@ -81,7 +81,6 @@ defaults.py:10:12: ICN001 [*] `seaborn` should be imported as `sns`
 10 |     import seaborn
    |            ^^^^^^^ ICN001
 11 |     import tkinter
-12 |     import networkx
    |
    = help: Alias `seaborn` to `sns`
 
@@ -92,7 +91,7 @@ defaults.py:10:12: ICN001 [*] `seaborn` should be imported as `sns`
 10    |-    import seaborn
    10 |+    import seaborn as sns
 11 11 |     import tkinter
-12 12 |     import networkx
+12 12 | 
 13 13 | 
 
 defaults.py:11:12: ICN001 [*] `tkinter` should be imported as `tk`
@@ -101,7 +100,6 @@ defaults.py:11:12: ICN001 [*] `tkinter` should be imported as `tk`
 10 |     import seaborn
 11 |     import tkinter
    |            ^^^^^^^ ICN001
-12 |     import networkx
    |
    = help: Alias `tkinter` to `tk`
 
@@ -111,172 +109,130 @@ defaults.py:11:12: ICN001 [*] `tkinter` should be imported as `tk`
 10 10 |     import seaborn
 11    |-    import tkinter
    11 |+    import tkinter as tk
-12 12 |     import networkx
+12 12 | 
 13 13 | 
-14 14 | 
+14 14 | def unconventional_aliases():
 
-defaults.py:12:12: ICN001 [*] `networkx` should be imported as `nx`
+defaults.py:15:22: ICN001 [*] `altair` should be imported as `alt`
    |
-10 |     import seaborn
-11 |     import tkinter
-12 |     import networkx
-   |            ^^^^^^^^ ICN001
-   |
-   = help: Alias `networkx` to `nx`
-
-ℹ Suggested fix
-9  9  |     import pandas
-10 10 |     import seaborn
-11 11 |     import tkinter
-12    |-    import networkx
-   12 |+    import networkx as nx
-13 13 | 
-14 14 | 
-15 15 | def unconventional_aliases():
-
-defaults.py:16:22: ICN001 [*] `altair` should be imported as `alt`
-   |
-15 | def unconventional_aliases():
-16 |     import altair as altr
+14 | def unconventional_aliases():
+15 |     import altair as altr
    |                      ^^^^ ICN001
-17 |     import matplotlib.pyplot as plot
-18 |     import numpy as nmp
+16 |     import matplotlib.pyplot as plot
+17 |     import numpy as nmp
    |
    = help: Alias `altair` to `alt`
 
 ℹ Suggested fix
+12 12 | 
 13 13 | 
-14 14 | 
-15 15 | def unconventional_aliases():
-16    |-    import altair as altr
-   16 |+    import altair as alt
-17 17 |     import matplotlib.pyplot as plot
-18 18 |     import numpy as nmp
-19 19 |     import pandas as pdas
+14 14 | def unconventional_aliases():
+15    |-    import altair as altr
+   15 |+    import altair as alt
+16 16 |     import matplotlib.pyplot as plot
+17 17 |     import numpy as nmp
+18 18 |     import pandas as pdas
 
-defaults.py:17:33: ICN001 [*] `matplotlib.pyplot` should be imported as `plt`
+defaults.py:16:33: ICN001 [*] `matplotlib.pyplot` should be imported as `plt`
    |
-15 | def unconventional_aliases():
-16 |     import altair as altr
-17 |     import matplotlib.pyplot as plot
+14 | def unconventional_aliases():
+15 |     import altair as altr
+16 |     import matplotlib.pyplot as plot
    |                                 ^^^^ ICN001
-18 |     import numpy as nmp
-19 |     import pandas as pdas
+17 |     import numpy as nmp
+18 |     import pandas as pdas
    |
    = help: Alias `matplotlib.pyplot` to `plt`
 
 ℹ Suggested fix
-14 14 | 
-15 15 | def unconventional_aliases():
-16 16 |     import altair as altr
-17    |-    import matplotlib.pyplot as plot
-   17 |+    import matplotlib.pyplot as plt
-18 18 |     import numpy as nmp
-19 19 |     import pandas as pdas
-20 20 |     import seaborn as sbrn
+13 13 | 
+14 14 | def unconventional_aliases():
+15 15 |     import altair as altr
+16    |-    import matplotlib.pyplot as plot
+   16 |+    import matplotlib.pyplot as plt
+17 17 |     import numpy as nmp
+18 18 |     import pandas as pdas
+19 19 |     import seaborn as sbrn
 
-defaults.py:18:21: ICN001 [*] `numpy` should be imported as `np`
+defaults.py:17:21: ICN001 [*] `numpy` should be imported as `np`
    |
-16 |     import altair as altr
-17 |     import matplotlib.pyplot as plot
-18 |     import numpy as nmp
+15 |     import altair as altr
+16 |     import matplotlib.pyplot as plot
+17 |     import numpy as nmp
    |                     ^^^ ICN001
-19 |     import pandas as pdas
-20 |     import seaborn as sbrn
+18 |     import pandas as pdas
+19 |     import seaborn as sbrn
    |
    = help: Alias `numpy` to `np`
 
 ℹ Suggested fix
-15 15 | def unconventional_aliases():
-16 16 |     import altair as altr
-17 17 |     import matplotlib.pyplot as plot
-18    |-    import numpy as nmp
-   18 |+    import numpy as np
-19 19 |     import pandas as pdas
-20 20 |     import seaborn as sbrn
-21 21 |     import tkinter as tkr
+14 14 | def unconventional_aliases():
+15 15 |     import altair as altr
+16 16 |     import matplotlib.pyplot as plot
+17    |-    import numpy as nmp
+   17 |+    import numpy as np
+18 18 |     import pandas as pdas
+19 19 |     import seaborn as sbrn
+20 20 |     import tkinter as tkr
 
-defaults.py:19:22: ICN001 [*] `pandas` should be imported as `pd`
+defaults.py:18:22: ICN001 [*] `pandas` should be imported as `pd`
    |
-17 |     import matplotlib.pyplot as plot
-18 |     import numpy as nmp
-19 |     import pandas as pdas
+16 |     import matplotlib.pyplot as plot
+17 |     import numpy as nmp
+18 |     import pandas as pdas
    |                      ^^^^ ICN001
-20 |     import seaborn as sbrn
-21 |     import tkinter as tkr
+19 |     import seaborn as sbrn
+20 |     import tkinter as tkr
    |
    = help: Alias `pandas` to `pd`
 
 ℹ Suggested fix
-16 16 |     import altair as altr
-17 17 |     import matplotlib.pyplot as plot
-18 18 |     import numpy as nmp
-19    |-    import pandas as pdas
-   19 |+    import pandas as pd
-20 20 |     import seaborn as sbrn
-21 21 |     import tkinter as tkr
-22 22 |     import networkx as nxy
+15 15 |     import altair as altr
+16 16 |     import matplotlib.pyplot as plot
+17 17 |     import numpy as nmp
+18    |-    import pandas as pdas
+   18 |+    import pandas as pd
+19 19 |     import seaborn as sbrn
+20 20 |     import tkinter as tkr
+21 21 | 
 
-defaults.py:20:23: ICN001 [*] `seaborn` should be imported as `sns`
+defaults.py:19:23: ICN001 [*] `seaborn` should be imported as `sns`
    |
-18 |     import numpy as nmp
-19 |     import pandas as pdas
-20 |     import seaborn as sbrn
+17 |     import numpy as nmp
+18 |     import pandas as pdas
+19 |     import seaborn as sbrn
    |                       ^^^^ ICN001
-21 |     import tkinter as tkr
-22 |     import networkx as nxy
+20 |     import tkinter as tkr
    |
    = help: Alias `seaborn` to `sns`
 
 ℹ Suggested fix
-17 17 |     import matplotlib.pyplot as plot
-18 18 |     import numpy as nmp
-19 19 |     import pandas as pdas
-20    |-    import seaborn as sbrn
-   20 |+    import seaborn as sns
-21 21 |     import tkinter as tkr
-22 22 |     import networkx as nxy
-23 23 | 
+16 16 |     import matplotlib.pyplot as plot
+17 17 |     import numpy as nmp
+18 18 |     import pandas as pdas
+19    |-    import seaborn as sbrn
+   19 |+    import seaborn as sns
+20 20 |     import tkinter as tkr
+21 21 | 
+22 22 | 
 
-defaults.py:21:23: ICN001 [*] `tkinter` should be imported as `tk`
+defaults.py:20:23: ICN001 [*] `tkinter` should be imported as `tk`
    |
-19 |     import pandas as pdas
-20 |     import seaborn as sbrn
-21 |     import tkinter as tkr
+18 |     import pandas as pdas
+19 |     import seaborn as sbrn
+20 |     import tkinter as tkr
    |                       ^^^ ICN001
-22 |     import networkx as nxy
    |
    = help: Alias `tkinter` to `tk`
 
 ℹ Suggested fix
-18 18 |     import numpy as nmp
-19 19 |     import pandas as pdas
-20 20 |     import seaborn as sbrn
-21    |-    import tkinter as tkr
-   21 |+    import tkinter as tk
-22 22 |     import networkx as nxy
-23 23 | 
-24 24 | def conventional_aliases():
-
-defaults.py:22:24: ICN001 [*] `networkx` should be imported as `nx`
-   |
-20 |     import seaborn as sbrn
-21 |     import tkinter as tkr
-22 |     import networkx as nxy
-   |                        ^^^ ICN001
-23 | 
-24 | def conventional_aliases():
-   |
-   = help: Alias `networkx` to `nx`
-
-ℹ Suggested fix
-19 19 |     import pandas as pdas
-20 20 |     import seaborn as sbrn
-21 21 |     import tkinter as tkr
-22    |-    import networkx as nxy
-   22 |+    import networkx as nx
-23 23 | 
-24 24 | def conventional_aliases():
-25 25 |     import altair as alt
+17 17 |     import numpy as nmp
+18 18 |     import pandas as pdas
+19 19 |     import seaborn as sbrn
+20    |-    import tkinter as tkr
+   20 |+    import tkinter as tk
+21 21 | 
+22 22 | 
+23 23 | def conventional_aliases():
 
 

crates/ruff/src/rules/flake8_logging_format/violations.rs

@@ -21,19 +21,6 @@ use ruff_macros::{derive_message_formats, violation};
 /// As an alternative to `extra`, passing values as arguments to the logging
 /// method can also be used to defer string formatting until required.
 ///
-/// ## Known problems
-///
-/// This rule detects uses of the `logging` module via a heuristic.
-/// Specifically, it matches against:
-///
-/// - Uses of the `logging` module itself (e.g., `import logging; logging.info(...)`).
-/// - Uses of `flask.current_app.logger` (e.g., `from flask import current_app; current_app.logger.info(...)`).
-/// - Objects whose name starts with `log` or ends with `logger` or `logging`,
-///   when used in the same file in which they are defined (e.g., `logger = logging.getLogger(); logger.info(...)`).
-/// - Imported objects marked as loggers via the [`logger-objects`] setting, which can be
-///   used to enforce these rules against shared logger objects (e.g., `from module import logger; logger.info(...)`,
-///   when [`logger-objects`] is set to `["module.logger"]`).
-///
 /// ## Example
 /// ```python
 /// import logging
@@ -67,9 +54,6 @@ use ruff_macros::{derive_message_formats, violation};
 /// logging.info("%s - Something happened", user)
 /// ```
 ///
-/// ## Options
-/// - `logger-objects`
-///
 /// ## References
 /// - [Python documentation: `logging`](https://docs.python.org/3/library/logging.html)
 /// - [Python documentation: Optimization](https://docs.python.org/3/howto/logging.html#optimization)
@@ -105,19 +89,6 @@ impl Violation for LoggingStringFormat {
 /// As an alternative to `extra`, passing values as arguments to the logging
 /// method can also be used to defer string formatting until required.
 ///
-/// ## Known problems
-///
-/// This rule detects uses of the `logging` module via a heuristic.
-/// Specifically, it matches against:
-///
-/// - Uses of the `logging` module itself (e.g., `import logging; logging.info(...)`).
-/// - Uses of `flask.current_app.logger` (e.g., `from flask import current_app; current_app.logger.info(...)`).
-/// - Objects whose name starts with `log` or ends with `logger` or `logging`,
-///   when used in the same file in which they are defined (e.g., `logger = logging.getLogger(); logger.info(...)`).
-/// - Imported objects marked as loggers via the [`logger-objects`] setting, which can be
-///   used to enforce these rules against shared logger objects (e.g., `from module import logger; logger.info(...)`,
-///   when [`logger-objects`] is set to `["module.logger"]`).
-///
 /// ## Example
 /// ```python
 /// import logging
@@ -151,9 +122,6 @@ impl Violation for LoggingStringFormat {
 /// logging.info("%s - Something happened", user)
 /// ```
 ///
-/// ## Options
-/// - `logger-objects`
-///
 /// ## References
 /// - [Python documentation: `logging`](https://docs.python.org/3/library/logging.html)
 /// - [Python documentation: Optimization](https://docs.python.org/3/howto/logging.html#optimization)
@@ -188,19 +156,6 @@ impl Violation for LoggingPercentFormat {
 /// As an alternative to `extra`, passing values as arguments to the logging
 /// method can also be used to defer string formatting until required.
 ///
-/// ## Known problems
-///
-/// This rule detects uses of the `logging` module via a heuristic.
-/// Specifically, it matches against:
-///
-/// - Uses of the `logging` module itself (e.g., `import logging; logging.info(...)`).
-/// - Uses of `flask.current_app.logger` (e.g., `from flask import current_app; current_app.logger.info(...)`).
-/// - Objects whose name starts with `log` or ends with `logger` or `logging`,
-///   when used in the same file in which they are defined (e.g., `logger = logging.getLogger(); logger.info(...)`).
-/// - Imported objects marked as loggers via the [`logger-objects`] setting, which can be
-///   used to enforce these rules against shared logger objects (e.g., `from module import logger; logger.info(...)`,
-///   when [`logger-objects`] is set to `["module.logger"]`).
-///
 /// ## Example
 /// ```python
 /// import logging
@@ -234,9 +189,6 @@ impl Violation for LoggingPercentFormat {
 /// logging.info("%s - Something happened", user)
 /// ```
 ///
-/// ## Options
-/// - `logger-objects`
-///
 /// ## References
 /// - [Python documentation: `logging`](https://docs.python.org/3/library/logging.html)
 /// - [Python documentation: Optimization](https://docs.python.org/3/howto/logging.html#optimization)
@@ -270,19 +222,6 @@ impl Violation for LoggingStringConcat {
 /// As an alternative to `extra`, passing values as arguments to the logging
 /// method can also be used to defer string formatting until required.
 ///
-/// ## Known problems
-///
-/// This rule detects uses of the `logging` module via a heuristic.
-/// Specifically, it matches against:
-///
-/// - Uses of the `logging` module itself (e.g., `import logging; logging.info(...)`).
-/// - Uses of `flask.current_app.logger` (e.g., `from flask import current_app; current_app.logger.info(...)`).
-/// - Objects whose name starts with `log` or ends with `logger` or `logging`,
-///   when used in the same file in which they are defined (e.g., `logger = logging.getLogger(); logger.info(...)`).
-/// - Imported objects marked as loggers via the [`logger-objects`] setting, which can be
-///   used to enforce these rules against shared logger objects (e.g., `from module import logger; logger.info(...)`,
-///   when [`logger-objects`] is set to `["module.logger"]`).
-///
 /// ## Example
 /// ```python
 /// import logging
@@ -316,9 +255,6 @@ impl Violation for LoggingStringConcat {
 /// logging.info("%s - Something happened", user)
 /// ```
 ///
-/// ## Options
-/// - `logger-objects`
-///
 /// ## References
 /// - [Python documentation: `logging`](https://docs.python.org/3/library/logging.html)
 /// - [Python documentation: Optimization](https://docs.python.org/3/howto/logging.html#optimization)
@@ -340,19 +276,6 @@ impl Violation for LoggingFString {
 /// `logging.warning` and `logging.Logger.warning`, which are functionally
 /// equivalent.
 ///
-/// ## Known problems
-///
-/// This rule detects uses of the `logging` module via a heuristic.
-/// Specifically, it matches against:
-///
-/// - Uses of the `logging` module itself (e.g., `import logging; logging.info(...)`).
-/// - Uses of `flask.current_app.logger` (e.g., `from flask import current_app; current_app.logger.info(...)`).
-/// - Objects whose name starts with `log` or ends with `logger` or `logging`,
-///   when used in the same file in which they are defined (e.g., `logger = logging.getLogger(); logger.info(...)`).
-/// - Imported objects marked as loggers via the [`logger-objects`] setting, which can be
-///   used to enforce these rules against shared logger objects (e.g., `from module import logger; logger.info(...)`,
-///   when [`logger-objects`] is set to `["module.logger"]`).
-///
 /// ## Example
 /// ```python
 /// import logging
@@ -367,9 +290,6 @@ impl Violation for LoggingFString {
 /// logging.warning("Something happened")
 /// ```
 ///
-/// ## Options
-/// - `logger-objects`
-///
 /// ## References
 /// - [Python documentation: `logging.warning`](https://docs.python.org/3/library/logging.html#logging.warning)
 /// - [Python documentation: `logging.Logger.warning`](https://docs.python.org/3/library/logging.html#logging.Logger.warning)
@@ -400,19 +320,6 @@ impl AlwaysAutofixableViolation for LoggingWarn {
 /// the `LogRecord` constructor will raise a `KeyError` when the `LogRecord` is
 /// constructed.
 ///
-/// ## Known problems
-///
-/// This rule detects uses of the `logging` module via a heuristic.
-/// Specifically, it matches against:
-///
-/// - Uses of the `logging` module itself (e.g., `import logging; logging.info(...)`).
-/// - Uses of `flask.current_app.logger` (e.g., `from flask import current_app; current_app.logger.info(...)`).
-/// - Objects whose name starts with `log` or ends with `logger` or `logging`,
-///   when used in the same file in which they are defined (e.g., `logger = logging.getLogger(); logger.info(...)`).
-/// - Imported objects marked as loggers via the [`logger-objects`] setting, which can be
-///   used to enforce these rules against shared logger objects (e.g., `from module import logger; logger.info(...)`,
-///   when [`logger-objects`] is set to `["module.logger"]`).
-///
 /// ## Example
 /// ```python
 /// import logging
@@ -435,9 +342,6 @@ impl AlwaysAutofixableViolation for LoggingWarn {
 /// logging.info("Something happened", extra=dict(user=username))
 /// ```
 ///
-/// ## Options
-/// - `logger-objects`
-///
 /// ## References
 /// - [Python documentation: LogRecord attributes](https://docs.python.org/3/library/logging.html#logrecord-attributes)
 #[violation]
@@ -461,19 +365,6 @@ impl Violation for LoggingExtraAttrClash {
 /// `logging.exception`. Using `logging.exception` is more concise, more
 /// readable, and conveys the intent of the logging statement more clearly.
 ///
-/// ## Known problems
-///
-/// This rule detects uses of the `logging` module via a heuristic.
-/// Specifically, it matches against:
-///
-/// - Uses of the `logging` module itself (e.g., `import logging; logging.info(...)`).
-/// - Uses of `flask.current_app.logger` (e.g., `from flask import current_app; current_app.logger.info(...)`).
-/// - Objects whose name starts with `log` or ends with `logger` or `logging`,
-///   when used in the same file in which they are defined (e.g., `logger = logging.getLogger(); logger.info(...)`).
-/// - Imported objects marked as loggers via the [`logger-objects`] setting, which can be
-///   used to enforce these rules against shared logger objects (e.g., `from module import logger; logger.info(...)`,
-///   when [`logger-objects`] is set to `["module.logger"]`).
-///
 /// ## Example
 /// ```python
 /// import logging
@@ -494,9 +385,6 @@ impl Violation for LoggingExtraAttrClash {
 ///     logging.exception("Exception occurred")
 /// ```
 ///
-/// ## Options
-/// - `logger-objects`
-///
 /// ## References
 /// - [Python documentation: `logging.exception`](https://docs.python.org/3/library/logging.html#logging.exception)
 /// - [Python documentation: `exception`](https://docs.python.org/3/library/logging.html#logging.Logger.exception)
@@ -522,19 +410,6 @@ impl Violation for LoggingExcInfo {
 /// Passing `exc_info=True` to `logging.exception` calls is redundant, as is
 /// passing `exc_info=False` to `logging.error` calls.
 ///
-/// ## Known problems
-///
-/// This rule detects uses of the `logging` module via a heuristic.
-/// Specifically, it matches against:
-///
-/// - Uses of the `logging` module itself (e.g., `import logging; logging.info(...)`).
-/// - Uses of `flask.current_app.logger` (e.g., `from flask import current_app; current_app.logger.info(...)`).
-/// - Objects whose name starts with `log` or ends with `logger` or `logging`,
-///   when used in the same file in which they are defined (e.g., `logger = logging.getLogger(); logger.info(...)`).
-/// - Imported objects marked as loggers via the [`logger-objects`] setting, which can be
-///   used to enforce these rules against shared logger objects (e.g., `from module import logger; logger.info(...)`,
-///   when [`logger-objects`] is set to `["module.logger"]`).
-///
 /// ## Example
 /// ```python
 /// import logging
@@ -555,9 +430,6 @@ impl Violation for LoggingExcInfo {
 ///     logging.exception("Exception occurred")
 /// ```
 ///
-/// ## Options
-/// - `logger-objects`
-///
 /// ## References
 /// - [Python documentation: `logging.exception`](https://docs.python.org/3/library/logging.html#logging.exception)
 /// - [Python documentation: `exception`](https://docs.python.org/3/library/logging.html#logging.Logger.exception)

crates/ruff/src/rules/flake8_pie/rules/duplicate_class_field_definition.rs

@@ -85,9 +85,7 @@ pub(crate) fn duplicate_class_field_definition(checker: &mut Checker, body: &[St
                     checker.locator(),
                     checker.indexer(),
                 );
-                diagnostic.set_fix(Fix::suggested(edit).isolate(Checker::isolation(Some(
-                    checker.semantic().current_statement_id(),
-                ))));
+                diagnostic.set_fix(Fix::suggested(edit).isolate(checker.statement_isolation()));
             }
             checker.diagnostics.push(diagnostic);
         }

crates/ruff/src/rules/flake8_pyi/rules/duplicate_union_member.rs

@@ -50,12 +50,12 @@ pub(crate) fn duplicate_union_member<'a>(checker: &mut Checker, expr: &'a Expr)
                 // parent without the duplicate.
 
                 // If the parent node is not a `BinOp` we will not perform a fix
-                if let Some(parent @ Expr::BinOp(ast::ExprBinOp { left, right, .. })) = parent {
+                if let Some(Expr::BinOp(ast::ExprBinOp { left, right, .. })) = parent {
                     // Replace the parent with its non-duplicate child.
                     let child = if expr == left.as_ref() { right } else { left };
                     diagnostic.set_fix(Fix::automatic(Edit::range_replacement(
                         checker.locator().slice(child.range()).to_string(),
-                        parent.range(),
+                        parent.unwrap().range(),
                     )));
                 }
             }

crates/ruff/src/rules/flake8_pyi/rules/ellipsis_in_non_empty_class_body.rs

@@ -69,9 +69,7 @@ pub(crate) fn ellipsis_in_non_empty_class_body(checker: &mut Checker, body: &[St
                     checker.locator(),
                     checker.indexer(),
                 );
-                diagnostic.set_fix(Fix::automatic(edit).isolate(Checker::isolation(Some(
-                    checker.semantic().current_statement_id(),
-                ))));
+                diagnostic.set_fix(Fix::automatic(edit).isolate(checker.statement_isolation()));
             }
             checker.diagnostics.push(diagnostic);
         }

crates/ruff/src/rules/flake8_pyi/rules/pass_in_class_body.rs

@@ -36,9 +36,7 @@ pub(crate) fn pass_in_class_body(checker: &mut Checker, class_def: &ast::StmtCla
         if checker.patch(diagnostic.kind.rule()) {
             let edit =
                 autofix::edits::delete_stmt(stmt, Some(stmt), checker.locator(), checker.indexer());
-            diagnostic.set_fix(Fix::automatic(edit).isolate(Checker::isolation(Some(
-                checker.semantic().current_statement_id(),
-            ))));
+            diagnostic.set_fix(Fix::automatic(edit).isolate(checker.statement_isolation()));
         }
         checker.diagnostics.push(diagnostic);
     }

crates/ruff/src/rules/flake8_pyi/rules/str_or_repr_defined_in_stub.rs

@@ -99,9 +99,7 @@ pub(crate) fn str_or_repr_defined_in_stub(checker: &mut Checker, stmt: &Stmt) {
         let stmt = checker.semantic().current_statement();
         let parent = checker.semantic().current_statement_parent();
         let edit = delete_stmt(stmt, parent, checker.locator(), checker.indexer());
-        diagnostic.set_fix(Fix::automatic(edit).isolate(Checker::isolation(
-            checker.semantic().current_statement_parent_id(),
-        )));
+        diagnostic.set_fix(Fix::automatic(edit).isolate(checker.parent_isolation()));
     }
     checker.diagnostics.push(diagnostic);
 }

crates/ruff/src/rules/flake8_pytest_style/rules/assertion.rs

@@ -1,7 +1,7 @@
 use std::borrow::Cow;
 
+use anyhow::bail;
 use anyhow::Result;
-use anyhow::{bail, Context};
 use libcst_native::{
     self, Assert, BooleanOp, CompoundStatement, Expression, ParenthesizableWhitespace,
     ParenthesizedNode, SimpleStatementLine, SimpleWhitespace, SmallStatement, Statement,
@@ -635,8 +635,9 @@ fn parenthesize<'a>(expression: Expression<'a>, parent: &Expression<'a>) -> Expr
 /// `assert a == "hello"` and `assert b == "world"`.
 fn fix_composite_condition(stmt: &Stmt, locator: &Locator, stylist: &Stylist) -> Result<Edit> {
     // Infer the indentation of the outer block.
-    let outer_indent =
-        whitespace::indentation(locator, stmt).context("Unable to fix multiline statement")?;
+    let Some(outer_indent) = whitespace::indentation(locator, stmt) else {
+        bail!("Unable to fix multiline statement");
+    };
 
     // Extract the module text.
     let contents = locator.lines(stmt.range());
@@ -671,11 +672,11 @@ fn fix_composite_condition(stmt: &Stmt, locator: &Locator, stylist: &Stylist) ->
         &mut indented_block.body
     };
 
-    let [Statement::Simple(simple_statement_line)] = statements.as_slice() else {
+    let [Statement::Simple(simple_statement_line)] = &statements[..] else {
         bail!("Expected one simple statement")
     };
 
-    let [SmallStatement::Assert(assert_statement)] = simple_statement_line.body.as_slice() else {
+    let [SmallStatement::Assert(assert_statement)] = &simple_statement_line.body[..] else {
         bail!("Expected simple statement to be an assert")
     };
 
@@ -753,13 +754,10 @@ pub(crate) fn composite_condition(
             if matches!(composite, CompositionKind::Simple)
                 && msg.is_none()
                 && !checker.indexer().comment_ranges().intersects(stmt.range())
-                && !checker
-                    .indexer()
-                    .in_multi_statement_line(stmt, checker.locator())
             {
-                diagnostic.try_set_fix(|| {
+                #[allow(deprecated)]
+                diagnostic.try_set_fix_from_edit(|| {
                     fix_composite_condition(stmt, checker.locator(), checker.stylist())
-                        .map(Fix::suggested)
                 });
             }
         }

crates/ruff/src/rules/flake8_pytest_style/rules/parametrize.rs

@@ -1,16 +1,18 @@
+use rustc_hash::FxHashMap;
 use std::hash::BuildHasherDefault;
 
-use rustc_hash::FxHashMap;
+use ruff_python_ast::{
+    self as ast, Arguments, Constant, Decorator, Expr, ExprContext, PySourceType, Ranged,
+};
+use ruff_python_parser::{lexer, AsMode, Tok};
+use ruff_text_size::{TextRange, TextSize};
 
 use ruff_diagnostics::{AutofixKind, Diagnostic, Edit, Fix, Violation};
 use ruff_macros::{derive_message_formats, violation};
 use ruff_python_ast::comparable::ComparableExpr;
-use ruff_python_ast::node::AstNode;
-use ruff_python_ast::parenthesize::parenthesized_range;
-use ruff_python_ast::{self as ast, Arguments, Constant, Decorator, Expr, ExprContext, Ranged};
 use ruff_python_codegen::Generator;
 use ruff_python_trivia::{SimpleTokenKind, SimpleTokenizer};
-use ruff_text_size::{TextRange, TextSize};
+use ruff_source_file::Locator;
 
 use crate::checkers::ast::Checker;
 use crate::registry::{AsRule, Rule};
@@ -72,7 +74,7 @@ use super::helpers::{is_pytest_parametrize, split_names};
 /// - [`pytest` documentation: How to parametrize fixtures and test functions](https://docs.pytest.org/en/latest/how-to/parametrize.html#pytest-mark-parametrize)
 #[violation]
 pub struct PytestParametrizeNamesWrongType {
-    expected: types::ParametrizeNameType,
+    pub expected: types::ParametrizeNameType,
 }
 
 impl Violation for PytestParametrizeNamesWrongType {
@@ -157,8 +159,8 @@ impl Violation for PytestParametrizeNamesWrongType {
 /// - [`pytest` documentation: How to parametrize fixtures and test functions](https://docs.pytest.org/en/latest/how-to/parametrize.html#pytest-mark-parametrize)
 #[violation]
 pub struct PytestParametrizeValuesWrongType {
-    values: types::ParametrizeValuesType,
-    row: types::ParametrizeValuesRowType,
+    pub values: types::ParametrizeValuesType,
+    pub row: types::ParametrizeValuesRowType,
 }
 
 impl Violation for PytestParametrizeValuesWrongType {
@@ -281,12 +283,34 @@ fn elts_to_csv(elts: &[Expr], generator: Generator) -> Option<String> {
 fn get_parametrize_name_range(
     decorator: &Decorator,
     expr: &Expr,
-    source: &str,
-) -> Option<TextRange> {
-    decorator
-        .expression
-        .as_call_expr()
-        .and_then(|call| parenthesized_range(expr.into(), call.arguments.as_any_node_ref(), source))
+    locator: &Locator,
+    source_type: PySourceType,
+) -> TextRange {
+    let mut locations = Vec::new();
+    let mut name_range = None;
+
+    // The parenthesis are not part of the AST, so we need to tokenize the
+    // decorator to find them.
+    for (tok, range) in lexer::lex_starts_at(
+        locator.slice(decorator.range()),
+        source_type.as_mode(),
+        decorator.start(),
+    )
+    .flatten()
+    {
+        match tok {
+            Tok::Lpar => locations.push(range.start()),
+            Tok::Rpar => {
+                if let Some(start) = locations.pop() {
+                    name_range = Some(TextRange::new(start, range.end()));
+                }
+            }
+            // Stop after the first argument.
+            Tok::Comma => break,
+            _ => (),
+        }
+    }
+    name_range.unwrap_or_else(|| expr.range())
 }
 
 /// PT006
@@ -305,9 +329,9 @@ fn check_names(checker: &mut Checker, decorator: &Decorator, expr: &Expr) {
                         let name_range = get_parametrize_name_range(
                             decorator,
                             expr,
-                            checker.locator().contents(),
-                        )
-                        .unwrap_or(expr.range());
+                            checker.locator(),
+                            checker.source_type,
+                        );
                         let mut diagnostic = Diagnostic::new(
                             PytestParametrizeNamesWrongType {
                                 expected: names_type,
@@ -340,9 +364,9 @@ fn check_names(checker: &mut Checker, decorator: &Decorator, expr: &Expr) {
                         let name_range = get_parametrize_name_range(
                             decorator,
                             expr,
-                            checker.locator().contents(),
-                        )
-                        .unwrap_or(expr.range());
+                            checker.locator(),
+                            checker.source_type,
+                        );
                         let mut diagnostic = Diagnostic::new(
                             PytestParametrizeNamesWrongType {
                                 expected: names_type,

crates/ruff/src/rules/flake8_pytest_style/snapshots/ruff__rules__flake8_pytest_style__tests__PT018.snap

@@ -299,8 +299,6 @@ PT018.py:44:1: PT018 [*] Assertion should be broken down into multiple parts
    44 |+assert something
    45 |+assert something_else
 45 46 | assert something and something_else and something_third  # Error
-46 47 | 
-47 48 | 
 
 PT018.py:45:1: PT018 [*] Assertion should be broken down into multiple parts
    |
@@ -318,37 +316,5 @@ PT018.py:45:1: PT018 [*] Assertion should be broken down into multiple parts
 45    |-assert something and something_else and something_third  # Error
    45 |+assert something and something_else
    46 |+assert something_third
-46 47 | 
-47 48 | 
-48 49 | def test_multiline():
-
-PT018.py:49:5: PT018 Assertion should be broken down into multiple parts
-   |
-48 | def test_multiline():
-49 |     assert something and something_else; x = 1
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ PT018
-50 | 
-51 |     x = 1; assert something and something_else
-   |
-   = help: Break down assertion into multiple parts
-
-PT018.py:51:12: PT018 Assertion should be broken down into multiple parts
-   |
-49 |     assert something and something_else; x = 1
-50 | 
-51 |     x = 1; assert something and something_else
-   |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ PT018
-52 | 
-53 |     x = 1; \
-   |
-   = help: Break down assertion into multiple parts
-
-PT018.py:54:9: PT018 Assertion should be broken down into multiple parts
-   |
-53 |     x = 1; \
-54 |         assert something and something_else
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ PT018
-   |
-   = help: Break down assertion into multiple parts
 
 

crates/ruff/src/rules/flake8_return/helpers.rs

@@ -25,11 +25,19 @@ pub(super) fn result_exists(returns: &[&ast::StmtReturn]) -> bool {
 /// This method assumes that the statement is the last statement in its body; specifically, that
 /// the statement isn't followed by a semicolon, followed by a multi-line statement.
 pub(super) fn end_of_last_statement(stmt: &Stmt, locator: &Locator) -> TextSize {
-    // Find the end of the last line that's "part of" the statement.
-    for line in locator.after(stmt.end()).universal_newlines() {
-        if !line.ends_with('\\') {
-            return stmt.end() + line.end();
+    if stmt.end() == locator.text_len() {
+        // End-of-file, so just return the end of the statement.
+        stmt.end()
+    } else {
+        // Otherwise, find the end of the last line that's "part of" the statement.
+        let contents = locator.after(stmt.end());
+
+        for line in contents.universal_newlines() {
+            if !line.ends_with('\\') {
+                return stmt.end() + line.end();
+            }
         }
+
+        unreachable!("Expected to find end-of-statement")
     }
-    locator.text_len()
 }

crates/ruff/src/rules/flake8_return/snapshots/ruff__rules__flake8_return__tests__RET503_RET503.py.snap

@@ -380,24 +380,5 @@ RET503.py:320:9: RET503 [*] Missing explicit `return` at the end of function abl
 321 321 |             return "" \
 322 322 |                 ;  # type: ignore
     323 |+        return None
-323 324 | 
-324 325 | 
-325 326 | def end_of_file():
-
-RET503.py:328:5: RET503 [*] Missing explicit `return` at the end of function able to return non-`None` value
-    |
-326 |     if False:
-327 |         return 1
-328 |     x = 2 \
-    |     ^^^^^ RET503
-    |
-    = help: Add explicit `return` statement
-
-ℹ Suggested fix
-326 326 |     if False:
-327 327 |         return 1
-328 328 |     x = 2 \
-    329 |+
-    330 |+    return None
 
 

crates/ruff/src/rules/flake8_simplify/rules/ast_if.rs

@@ -11,8 +11,8 @@ use ruff_macros::{derive_message_formats, violation};
 use ruff_python_ast::comparable::{ComparableConstant, ComparableExpr, ComparableStmt};
 use ruff_python_ast::helpers::{any_over_expr, contains_effect};
 use ruff_python_ast::stmt_if::{if_elif_branches, IfElifBranch};
+use ruff_python_parser::first_colon_range;
 use ruff_python_semantic::SemanticModel;
-use ruff_python_trivia::{SimpleTokenKind, SimpleTokenizer};
 use ruff_source_file::{Locator, UniversalNewlines};
 
 use crate::checkers::ast::Checker;
@@ -369,10 +369,16 @@ pub(crate) fn nested_if_statements(
     };
 
     // Find the deepest nested if-statement, to inform the range.
-    let Some((test, _first_stmt)) = find_last_nested_if(body) else {
+    let Some((test, first_stmt)) = find_last_nested_if(body) else {
         return;
     };
 
+    let colon = first_colon_range(
+        TextRange::new(test.end(), first_stmt.start()),
+        checker.locator().contents(),
+        checker.source_type.is_jupyter(),
+    );
+
     // Check if the parent is already emitting a larger diagnostic including this if statement
     if let Some(Stmt::If(stmt_if)) = parent {
         if let Some((body, _range, _is_elif)) = nested_if_body(stmt_if) {
@@ -386,14 +392,10 @@ pub(crate) fn nested_if_statements(
         }
     }
 
-    let Some(colon) = SimpleTokenizer::starts_at(test.end(), checker.locator().contents())
-        .skip_trivia()
-        .find(|token| token.kind == SimpleTokenKind::Colon)
-    else {
-        return;
-    };
-
-    let mut diagnostic = Diagnostic::new(CollapsibleIf, TextRange::new(range.start(), colon.end()));
+    let mut diagnostic = Diagnostic::new(
+        CollapsibleIf,
+        colon.map_or(range, |colon| TextRange::new(range.start(), colon.end())),
+    );
     if checker.patch(diagnostic.kind.rule()) {
         // The fixer preserves comments in the nested body, but removes comments between
         // the outer and inner if statements.
@@ -719,16 +721,10 @@ pub(crate) fn if_with_same_arms(checker: &mut Checker, locator: &Locator, stmt_i
         // ...and the same comments
         let first_comments = checker
             .indexer()
-            .comment_ranges()
-            .comments_in_range(body_range(&current_branch, locator))
-            .iter()
-            .map(|range| locator.slice(*range));
+            .comments_in_range(body_range(&current_branch, locator), locator);
         let second_comments = checker
             .indexer()
-            .comment_ranges()
-            .comments_in_range(body_range(following_branch, locator))
-            .iter()
-            .map(|range| locator.slice(*range));
+            .comments_in_range(body_range(following_branch, locator), locator);
         if !first_comments.eq(second_comments) {
             continue;
         }

crates/ruff/src/rules/flake8_simplify/rules/ast_with.rs

@@ -1,12 +1,12 @@
 use log::error;
+use ruff_python_ast::{self as ast, Ranged, Stmt, WithItem};
+use ruff_text_size::TextRange;
 
 use ruff_diagnostics::{AutofixKind, Violation};
 use ruff_diagnostics::{Diagnostic, Fix};
 use ruff_macros::{derive_message_formats, violation};
-use ruff_python_ast::{self as ast, Ranged, Stmt, WithItem};
-use ruff_python_trivia::{SimpleTokenKind, SimpleTokenizer};
+use ruff_python_parser::first_colon_range;
 use ruff_source_file::UniversalNewlines;
-use ruff_text_size::TextRange;
 
 use crate::checkers::ast::Checker;
 use crate::line_width::LineWidth;
@@ -106,24 +106,32 @@ pub(crate) fn multiple_with_statements(
         }
     }
 
-    if let Some((is_async, items, _body)) = next_with(&with_stmt.body) {
+    if let Some((is_async, items, body)) = next_with(&with_stmt.body) {
         if is_async != with_stmt.is_async {
             // One of the statements is an async with, while the other is not,
             // we can't merge those statements.
             return;
         }
 
-        let Some(colon) = items.last().and_then(|item| {
-            SimpleTokenizer::starts_at(item.end(), checker.locator().contents())
-                .skip_trivia()
-                .find(|token| token.kind == SimpleTokenKind::Colon)
-        }) else {
-            return;
-        };
+        let last_item = items.last().expect("Expected items to be non-empty");
+        let colon = first_colon_range(
+            TextRange::new(
+                last_item
+                    .optional_vars
+                    .as_ref()
+                    .map_or(last_item.context_expr.end(), |v| v.end()),
+                body.first().expect("Expected body to be non-empty").start(),
+            ),
+            checker.locator().contents(),
+            checker.source_type.is_jupyter(),
+        );
 
         let mut diagnostic = Diagnostic::new(
             MultipleWithStatements,
-            TextRange::new(with_stmt.start(), colon.end()),
+            colon.map_or_else(
+                || with_stmt.range(),
+                |colon| TextRange::new(with_stmt.start(), colon.end()),
+            ),
         );
         if checker.patch(diagnostic.kind.rule()) {
             if !checker

crates/ruff/src/rules/flake8_simplify/rules/yoda_conditions.rs

@@ -8,9 +8,10 @@ use ruff_python_codegen::Stylist;
 use ruff_python_stdlib::str::{self};
 use ruff_source_file::Locator;
 
+use crate::autofix::codemods::CodegenStylist;
 use crate::autofix::snippet::SourceCodeSnippet;
 use crate::checkers::ast::Checker;
-use crate::cst::matchers::{match_comparison, transform_expression};
+use crate::cst::matchers::{match_comparison, match_expression};
 use crate::registry::AsRule;
 
 /// ## What it does
@@ -95,69 +96,68 @@ fn is_constant_like(expr: &Expr) -> bool {
 /// Generate a fix to reverse a comparison.
 fn reverse_comparison(expr: &Expr, locator: &Locator, stylist: &Stylist) -> Result<String> {
     let range = expr.range();
-    let source_code = locator.slice(range);
+    let contents = locator.slice(range);
 
-    transform_expression(source_code, stylist, |mut expression| {
-        let comparison = match_comparison(&mut expression)?;
+    let mut expression = match_expression(contents)?;
+    let comparison = match_comparison(&mut expression)?;
 
-        let left = (*comparison.left).clone();
+    let left = (*comparison.left).clone();
 
-        // Copy the right side to the left side.
-        comparison.left = Box::new(comparison.comparisons[0].comparator.clone());
+    // Copy the right side to the left side.
+    comparison.left = Box::new(comparison.comparisons[0].comparator.clone());
 
-        // Copy the left side to the right side.
-        comparison.comparisons[0].comparator = left;
+    // Copy the left side to the right side.
+    comparison.comparisons[0].comparator = left;
 
-        // Reverse the operator.
-        let op = comparison.comparisons[0].operator.clone();
-        comparison.comparisons[0].operator = match op {
-            CompOp::LessThan {
-                whitespace_before,
-                whitespace_after,
-            } => CompOp::GreaterThan {
-                whitespace_before,
-                whitespace_after,
-            },
-            CompOp::GreaterThan {
-                whitespace_before,
-                whitespace_after,
-            } => CompOp::LessThan {
-                whitespace_before,
-                whitespace_after,
-            },
-            CompOp::LessThanEqual {
-                whitespace_before,
-                whitespace_after,
-            } => CompOp::GreaterThanEqual {
-                whitespace_before,
-                whitespace_after,
-            },
-            CompOp::GreaterThanEqual {
-                whitespace_before,
-                whitespace_after,
-            } => CompOp::LessThanEqual {
-                whitespace_before,
-                whitespace_after,
-            },
-            CompOp::Equal {
-                whitespace_before,
-                whitespace_after,
-            } => CompOp::Equal {
-                whitespace_before,
-                whitespace_after,
-            },
-            CompOp::NotEqual {
-                whitespace_before,
-                whitespace_after,
-            } => CompOp::NotEqual {
-                whitespace_before,
-                whitespace_after,
-            },
-            _ => panic!("Expected comparison operator"),
-        };
+    // Reverse the operator.
+    let op = comparison.comparisons[0].operator.clone();
+    comparison.comparisons[0].operator = match op {
+        CompOp::LessThan {
+            whitespace_before,
+            whitespace_after,
+        } => CompOp::GreaterThan {
+            whitespace_before,
+            whitespace_after,
+        },
+        CompOp::GreaterThan {
+            whitespace_before,
+            whitespace_after,
+        } => CompOp::LessThan {
+            whitespace_before,
+            whitespace_after,
+        },
+        CompOp::LessThanEqual {
+            whitespace_before,
+            whitespace_after,
+        } => CompOp::GreaterThanEqual {
+            whitespace_before,
+            whitespace_after,
+        },
+        CompOp::GreaterThanEqual {
+            whitespace_before,
+            whitespace_after,
+        } => CompOp::LessThanEqual {
+            whitespace_before,
+            whitespace_after,
+        },
+        CompOp::Equal {
+            whitespace_before,
+            whitespace_after,
+        } => CompOp::Equal {
+            whitespace_before,
+            whitespace_after,
+        },
+        CompOp::NotEqual {
+            whitespace_before,
+            whitespace_after,
+        } => CompOp::NotEqual {
+            whitespace_before,
+            whitespace_after,
+        },
+        _ => panic!("Expected comparison operator"),
+    };
 
-        Ok(expression)
-    })
+    Ok(expression.codegen_stylist(stylist))
 }
 
 /// SIM300

crates/ruff/src/rules/flake8_type_checking/rules/empty_type_checking_block.rs

@@ -61,9 +61,7 @@ pub(crate) fn empty_type_checking_block(checker: &mut Checker, stmt: &ast::StmtI
         let stmt = checker.semantic().current_statement();
         let parent = checker.semantic().current_statement_parent();
         let edit = autofix::edits::delete_stmt(stmt, parent, checker.locator(), checker.indexer());
-        diagnostic.set_fix(Fix::automatic(edit).isolate(Checker::isolation(
-            checker.semantic().current_statement_parent_id(),
-        )));
+        diagnostic.set_fix(Fix::automatic(edit).isolate(checker.parent_isolation()));
     }
     checker.diagnostics.push(diagnostic);
 }

crates/ruff/src/rules/flake8_type_checking/rules/runtime_import_in_type_checking_block.rs

@@ -236,8 +236,7 @@ fn fix_imports(checker: &Checker, node_id: NodeId, imports: &[ImportBinding]) ->
     )?;
 
     Ok(
-        Fix::suggested_edits(remove_import_edit, add_import_edit.into_edits()).isolate(
-            Checker::isolation(checker.semantic().parent_statement_id(node_id)),
-        ),
+        Fix::suggested_edits(remove_import_edit, add_import_edit.into_edits())
+            .isolate(checker.parent_isolation()),
     )
 }

crates/ruff/src/rules/flake8_type_checking/rules/typing_only_runtime_import.rs

@@ -486,8 +486,7 @@ fn fix_imports(checker: &Checker, node_id: NodeId, imports: &[ImportBinding]) ->
     )?;
 
     Ok(
-        Fix::suggested_edits(remove_import_edit, add_import_edit.into_edits()).isolate(
-            Checker::isolation(checker.semantic().parent_statement_id(node_id)),
-        ),
+        Fix::suggested_edits(remove_import_edit, add_import_edit.into_edits())
+            .isolate(checker.parent_isolation()),
     )
 }

crates/ruff/src/rules/isort/comments.rs

@@ -1,7 +1,7 @@
 use std::borrow::Cow;
 
-use ruff_python_ast::Ranged;
-use ruff_python_index::Indexer;
+use ruff_python_ast::{PySourceType, Ranged};
+use ruff_python_parser::{lexer, AsMode, Tok};
 use ruff_source_file::Locator;
 use ruff_text_size::TextRange;
 
@@ -21,15 +21,20 @@ impl Ranged for Comment<'_> {
 pub(crate) fn collect_comments<'a>(
     range: TextRange,
     locator: &'a Locator,
-    indexer: &'a Indexer,
+    source_type: PySourceType,
 ) -> Vec<Comment<'a>> {
-    indexer
-        .comment_ranges()
-        .comments_in_range(range)
-        .iter()
-        .map(|range| Comment {
-            value: locator.slice(*range).into(),
-            range: *range,
+    let contents = locator.slice(range);
+    lexer::lex_starts_at(contents, source_type.as_mode(), range.start())
+        .flatten()
+        .filter_map(|(tok, range)| {
+            if let Tok::Comment(value) = tok {
+                Some(Comment {
+                    value: value.into(),
+                    range,
+                })
+            } else {
+                None
+            }
         })
         .collect()
 }

crates/ruff/src/rules/isort/rules/organize_imports.rs

@@ -1,16 +1,16 @@
 use std::path::Path;
 
 use itertools::{EitherOrBoth, Itertools};
+use ruff_python_ast::{PySourceType, Ranged, Stmt};
+use ruff_text_size::TextRange;
 
 use ruff_diagnostics::{AutofixKind, Diagnostic, Edit, Fix, Violation};
 use ruff_macros::{derive_message_formats, violation};
-use ruff_python_ast::whitespace::trailing_lines_end;
-use ruff_python_ast::{PySourceType, Ranged, Stmt};
+use ruff_python_ast::whitespace::{followed_by_multi_statement_line, trailing_lines_end};
 use ruff_python_codegen::Stylist;
 use ruff_python_index::Indexer;
 use ruff_python_trivia::{leading_indentation, textwrap::indent, PythonWhitespace};
 use ruff_source_file::{Locator, UniversalNewlines};
-use ruff_text_size::TextRange;
 
 use crate::line_width::LineWidth;
 use crate::registry::AsRule;
@@ -97,7 +97,7 @@ pub(crate) fn organize_imports(
     // Special-cases: there's leading or trailing content in the import block. These
     // are too hard to get right, and relatively rare, so flag but don't fix.
     if indexer.preceded_by_multi_statement_line(block.imports.first().unwrap(), locator)
-        || indexer.followed_by_multi_statement_line(block.imports.last().unwrap(), locator)
+        || followed_by_multi_statement_line(block.imports.last().unwrap(), locator)
     {
         return Some(Diagnostic::new(UnsortedImports, range));
     }
@@ -106,7 +106,7 @@ pub(crate) fn organize_imports(
     let comments = comments::collect_comments(
         TextRange::new(range.start(), locator.full_line_end(range.end())),
         locator,
-        indexer,
+        source_type,
     );
 
     let trailing_line_end = if block.trailer.is_none() {

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

@@ -39,7 +39,6 @@ mod tests {
     #[test_case(Rule::NewLineAfterLastParagraph, Path::new("D.py"))]
     #[test_case(Rule::NewLineAfterSectionName, Path::new("sections.py"))]
     #[test_case(Rule::NoBlankLineAfterFunction, Path::new("D.py"))]
-    #[test_case(Rule::FitsOnOneLine, Path::new("D200.py"))]
     #[test_case(Rule::NoBlankLineAfterFunction, Path::new("D202.py"))]
     #[test_case(Rule::BlankLineBeforeClass, Path::new("D.py"))]
     #[test_case(Rule::NoBlankLineBeforeFunction, Path::new("D.py"))]

crates/ruff/src/rules/pydocstyle/rules/one_liner.rs

@@ -74,8 +74,7 @@ pub(crate) fn one_liner(checker: &mut Checker, docstring: &Docstring) {
                 // characters, avoid applying the fix.
                 let body = docstring.body();
                 let trimmed = body.trim();
-                if trimmed.chars().rev().take_while(|c| *c == '\\').count() % 2 == 0
-                    && !trimmed.ends_with(trailing.chars().last().unwrap())
+                if !trimmed.ends_with(trailing.chars().last().unwrap())
                     && !trimmed.starts_with(leading.chars().last().unwrap())
                 {
                     diagnostic.set_fix(Fix::suggested(Edit::range_replacement(

crates/ruff/src/rules/pydocstyle/snapshots/ruff__rules__pydocstyle__tests__D200_D200.py.snap

@@ -1,45 +0,0 @@
----
-source: crates/ruff/src/rules/pydocstyle/mod.rs
----
-D200.py:2:5: D200 One-line docstring should fit on one line
-  |
-1 |   def func():
-2 |       """\
-  |  _____^
-3 | |     """
-  | |_______^ D200
-  |
-  = help: Reformat to one line
-
-D200.py:7:5: D200 [*] One-line docstring should fit on one line
-  |
-6 |   def func():
-7 |       """\\
-  |  _____^
-8 | |     """
-  | |_______^ D200
-  |
-  = help: Reformat to one line
-
-ℹ Suggested fix
-4 4 | 
-5 5 | 
-6 6 | def func():
-7   |-    """\\
-8   |-    """
-  7 |+    """\\"""
-9 8 | 
-10 9 | 
-11 10 | def func():
-
-D200.py:12:5: D200 One-line docstring should fit on one line
-   |
-11 |   def func():
-12 |       """\ \
-   |  _____^
-13 | |     """
-   | |_______^ D200
-   |
-   = help: Reformat to one line
-
-

crates/ruff/src/rules/pyflakes/fixes.rs

@@ -1,88 +1,93 @@
 use anyhow::{Context, Ok, Result};
+use ruff_python_ast::{Expr, Ranged};
+use ruff_text_size::TextRange;
 
 use ruff_diagnostics::Edit;
-use ruff_python_ast::{self as ast, Ranged};
 use ruff_python_codegen::Stylist;
 use ruff_python_semantic::Binding;
 use ruff_python_trivia::{SimpleTokenKind, SimpleTokenizer};
 use ruff_source_file::Locator;
 
-use crate::cst::matchers::{match_call_mut, match_dict, transform_expression};
+use crate::autofix::codemods::CodegenStylist;
+use crate::cst::matchers::{match_call_mut, match_dict, match_expression};
 
 /// Generate a [`Edit`] to remove unused keys from format dict.
 pub(super) fn remove_unused_format_arguments_from_dict(
     unused_arguments: &[usize],
-    dict: &ast::ExprDict,
+    stmt: &Expr,
     locator: &Locator,
     stylist: &Stylist,
 ) -> Result<Edit> {
-    let source_code = locator.slice(dict.range());
-    transform_expression(source_code, stylist, |mut expression| {
-        let dict = match_dict(&mut expression)?;
+    let module_text = locator.slice(stmt.range());
+    let mut tree = match_expression(module_text)?;
+    let dict = match_dict(&mut tree)?;
 
-        // Remove the elements at the given indexes.
-        let mut index = 0;
-        dict.elements.retain(|_| {
-            let is_unused = unused_arguments.contains(&index);
-            index += 1;
-            !is_unused
-        });
+    // Remove the elements at the given indexes.
+    let mut index = 0;
+    dict.elements.retain(|_| {
+        let is_unused = unused_arguments.contains(&index);
+        index += 1;
+        !is_unused
+    });
 
-        Ok(expression)
-    })
-    .map(|output| Edit::range_replacement(output, dict.range()))
+    Ok(Edit::range_replacement(
+        tree.codegen_stylist(stylist),
+        stmt.range(),
+    ))
 }
 
 /// Generate a [`Edit`] to remove unused keyword arguments from a `format` call.
 pub(super) fn remove_unused_keyword_arguments_from_format_call(
     unused_arguments: &[usize],
-    call: &ast::ExprCall,
+    location: TextRange,
     locator: &Locator,
     stylist: &Stylist,
 ) -> Result<Edit> {
-    let source_code = locator.slice(call.range());
-    transform_expression(source_code, stylist, |mut expression| {
-        let call = match_call_mut(&mut expression)?;
+    let module_text = locator.slice(location);
+    let mut tree = match_expression(module_text)?;
+    let call = match_call_mut(&mut tree)?;
 
-        // Remove the keyword arguments at the given indexes.
-        let mut index = 0;
-        call.args.retain(|arg| {
-            if arg.keyword.is_none() {
-                return true;
-            }
+    // Remove the keyword arguments at the given indexes.
+    let mut index = 0;
+    call.args.retain(|arg| {
+        if arg.keyword.is_none() {
+            return true;
+        }
 
-            let is_unused = unused_arguments.contains(&index);
-            index += 1;
-            !is_unused
-        });
+        let is_unused = unused_arguments.contains(&index);
+        index += 1;
+        !is_unused
+    });
 
-        Ok(expression)
-    })
-    .map(|output| Edit::range_replacement(output, call.range()))
+    Ok(Edit::range_replacement(
+        tree.codegen_stylist(stylist),
+        location,
+    ))
 }
 
 /// Generate a [`Edit`] to remove unused positional arguments from a `format` call.
 pub(crate) fn remove_unused_positional_arguments_from_format_call(
     unused_arguments: &[usize],
-    call: &ast::ExprCall,
+    location: TextRange,
     locator: &Locator,
     stylist: &Stylist,
 ) -> Result<Edit> {
-    let source_code = locator.slice(call.range());
-    transform_expression(source_code, stylist, |mut expression| {
-        let call = match_call_mut(&mut expression)?;
+    let module_text = locator.slice(location);
+    let mut tree = match_expression(module_text)?;
+    let call = match_call_mut(&mut tree)?;
 
-        // Remove any unused arguments.
-        let mut index = 0;
-        call.args.retain(|_| {
-            let is_unused = unused_arguments.contains(&index);
-            index += 1;
-            !is_unused
-        });
+    // Remove any unused arguments.
+    let mut index = 0;
+    call.args.retain(|_| {
+        let is_unused = unused_arguments.contains(&index);
+        index += 1;
+        !is_unused
+    });
 
-        Ok(expression)
-    })
-    .map(|output| Edit::range_replacement(output, call.range()))
+    Ok(Edit::range_replacement(
+        tree.codegen_stylist(stylist),
+        location,
+    ))
 }
 
 /// Generate a [`Edit`] to remove the binding from an exception handler.

crates/ruff/src/rules/pyflakes/rules/f_string_missing_placeholders.rs

@@ -62,7 +62,8 @@ fn find_useless_f_strings<'a>(
                 kind: StringKind::FString | StringKind::RawFString,
                 ..
             } => {
-                let first_char = locator.slice(TextRange::at(range.start(), TextSize::from(1)));
+                let first_char =
+                    &locator.contents()[TextRange::at(range.start(), TextSize::from(1))];
                 // f"..."  => f_position = 0
                 // fr"..." => f_position = 0
                 // rf"..." => f_position = 1

crates/ruff/src/rules/pyflakes/rules/strings.rs

@@ -1,6 +1,6 @@
 use std::string::ToString;
 
-use ruff_python_ast::{self as ast, Constant, Expr, Identifier, Keyword, Ranged};
+use ruff_python_ast::{self as ast, Constant, Expr, Identifier, Keyword};
 use ruff_text_size::TextRange;
 use rustc_hash::FxHashSet;
 
@@ -570,16 +570,15 @@ pub(crate) fn percent_format_extra_named_arguments(
     if summary.num_positional > 0 {
         return;
     }
-    let Expr::Dict(dict) = &right else {
+    let Expr::Dict(ast::ExprDict { keys, .. }) = &right else {
         return;
     };
     // If any of the keys are spread, abort.
-    if dict.keys.iter().any(Option::is_none) {
+    if keys.iter().any(Option::is_none) {
         return;
     }
 
-    let missing: Vec<(usize, &str)> = dict
-        .keys
+    let missing: Vec<(usize, &str)> = keys
         .iter()
         .enumerate()
         .filter_map(|(index, key)| match key {
@@ -614,7 +613,7 @@ pub(crate) fn percent_format_extra_named_arguments(
         diagnostic.try_set_fix(|| {
             let edit = remove_unused_format_arguments_from_dict(
                 &indexes,
-                dict,
+                right,
                 checker.locator(),
                 checker.stylist(),
             )?;
@@ -740,9 +739,9 @@ pub(crate) fn percent_format_star_requires_sequence(
 /// F522
 pub(crate) fn string_dot_format_extra_named_arguments(
     checker: &mut Checker,
-    call: &ast::ExprCall,
     summary: &FormatSummary,
     keywords: &[Keyword],
+    location: TextRange,
 ) {
     // If there are any **kwargs, abort.
     if has_star_star_kwargs(keywords) {
@@ -774,14 +773,14 @@ pub(crate) fn string_dot_format_extra_named_arguments(
         .collect();
     let mut diagnostic = Diagnostic::new(
         StringDotFormatExtraNamedArguments { missing: names },
-        call.range(),
+        location,
     );
     if checker.patch(diagnostic.kind.rule()) {
         let indexes: Vec<usize> = missing.iter().map(|(index, _)| *index).collect();
         diagnostic.try_set_fix(|| {
             let edit = remove_unused_keyword_arguments_from_format_call(
                 &indexes,
-                call,
+                location,
                 checker.locator(),
                 checker.stylist(),
             )?;
@@ -794,9 +793,9 @@ pub(crate) fn string_dot_format_extra_named_arguments(
 /// F523
 pub(crate) fn string_dot_format_extra_positional_arguments(
     checker: &mut Checker,
-    call: &ast::ExprCall,
     summary: &FormatSummary,
     args: &[Expr],
+    location: TextRange,
 ) {
     let missing: Vec<usize> = args
         .iter()
@@ -818,7 +817,7 @@ pub(crate) fn string_dot_format_extra_positional_arguments(
                 .map(ToString::to_string)
                 .collect::<Vec<String>>(),
         },
-        call.range(),
+        location,
     );
     if checker.patch(diagnostic.kind.rule()) {
         // We can only fix if the positional arguments we're removing don't require re-indexing
@@ -850,7 +849,7 @@ pub(crate) fn string_dot_format_extra_positional_arguments(
             diagnostic.try_set_fix(|| {
                 let edit = remove_unused_positional_arguments_from_format_call(
                     &missing,
-                    call,
+                    location,
                     checker.locator(),
                     checker.stylist(),
                 )?;
@@ -864,10 +863,10 @@ pub(crate) fn string_dot_format_extra_positional_arguments(
 /// F524
 pub(crate) fn string_dot_format_missing_argument(
     checker: &mut Checker,
-    call: &ast::ExprCall,
     summary: &FormatSummary,
     args: &[Expr],
     keywords: &[Keyword],
+    location: TextRange,
 ) {
     if has_star_args(args) || has_star_star_kwargs(keywords) {
         return;
@@ -899,7 +898,7 @@ pub(crate) fn string_dot_format_missing_argument(
     if !missing.is_empty() {
         checker.diagnostics.push(Diagnostic::new(
             StringDotFormatMissingArguments { missing },
-            call.range(),
+            location,
         ));
     }
 }
@@ -907,13 +906,12 @@ pub(crate) fn string_dot_format_missing_argument(
 /// F525
 pub(crate) fn string_dot_format_mixing_automatic(
     checker: &mut Checker,
-    call: &ast::ExprCall,
     summary: &FormatSummary,
+    location: TextRange,
 ) {
     if !(summary.autos.is_empty() || summary.indices.is_empty()) {
-        checker.diagnostics.push(Diagnostic::new(
-            StringDotFormatMixingAutomatic,
-            call.range(),
-        ));
+        checker
+            .diagnostics
+            .push(Diagnostic::new(StringDotFormatMixingAutomatic, location));
     }
 }

crates/ruff/src/rules/pyflakes/rules/unused_import.rs

@@ -217,7 +217,6 @@ pub(crate) fn unused_import(checker: &Checker, scope: &Scope, diagnostics: &mut
 }
 
 /// An unused import with its surrounding context.
-#[derive(Debug)]
 struct ImportBinding<'a> {
     /// The qualified name of the import (e.g., `typing.List` for `from typing import List`).
     import: AnyImport<'a>,
@@ -252,7 +251,5 @@ fn fix_imports(checker: &Checker, node_id: NodeId, imports: &[ImportBinding]) ->
         checker.stylist(),
         checker.indexer(),
     )?;
-    Ok(Fix::automatic(edit).isolate(Checker::isolation(
-        checker.semantic().parent_statement_id(node_id),
-    )))
+    Ok(Fix::automatic(edit).isolate(checker.parent_isolation()))
 }

crates/ruff/src/rules/pyflakes/rules/unused_variable.rs

@@ -1,6 +1,6 @@
 use itertools::Itertools;
 
-use ruff_diagnostics::{AutofixKind, Diagnostic, Edit, Fix, Violation};
+use ruff_diagnostics::{AutofixKind, Diagnostic, Edit, Fix, IsolationLevel, Violation};
 use ruff_macros::{derive_message_formats, violation};
 use ruff_python_ast::helpers::contains_effect;
 use ruff_python_ast::{self as ast, PySourceType, Ranged, Stmt};
@@ -206,7 +206,11 @@ fn remove_unused_variable(binding: &Binding, checker: &Checker) -> Option<Fix> {
     let node_id = binding.source?;
     let statement = checker.semantic().statement(node_id);
     let parent = checker.semantic().parent_statement(node_id);
-    let isolation = Checker::isolation(checker.semantic().parent_statement_id(node_id));
+    let isolation = checker
+        .semantic()
+        .parent_statement_id(node_id)
+        .map(|node_id| IsolationLevel::Group(node_id.into()))
+        .unwrap_or_default();
 
     // First case: simple assignment (`x = 1`)
     if let Stmt::Assign(ast::StmtAssign { targets, value, .. }) = statement {

crates/ruff/src/rules/pyflakes/snapshots/ruff__rules__pyflakes__tests__F401_F401_0.py.snap

@@ -190,78 +190,5 @@ F401_0.py:99:8: F401 [*] `foo.bar.baz` imported but unused
 99      |-import foo.bar.baz
 100 99  | 
 101 100 | print(bop.baz.read_csv("test.csv"))
-102 101 | 
-
-F401_0.py:105:12: F401 [*] `a1` imported but unused
-    |
-103 | # Test: isolated deletions.
-104 | if TYPE_CHECKING:
-105 |     import a1
-    |            ^^ F401
-106 | 
-107 |     import a2
-    |
-    = help: Remove unused import: `a1`
-
-ℹ Fix
-102 102 | 
-103 103 | # Test: isolated deletions.
-104 104 | if TYPE_CHECKING:
-105     |-    import a1
-106 105 | 
-107 106 |     import a2
-108 107 | 
-
-F401_0.py:107:12: F401 [*] `a2` imported but unused
-    |
-105 |     import a1
-106 | 
-107 |     import a2
-    |            ^^ F401
-    |
-    = help: Remove unused import: `a2`
-
-ℹ Fix
-104 104 | if TYPE_CHECKING:
-105 105 |     import a1
-106 106 | 
-107     |-    import a2
-108 107 | 
-109 108 | 
-110 109 | match *0, 1, *2:
-
-F401_0.py:112:16: F401 [*] `b1` imported but unused
-    |
-110 | match *0, 1, *2:
-111 |     case 0,:
-112 |         import b1
-    |                ^^ F401
-113 | 
-114 |         import b2
-    |
-    = help: Remove unused import: `b1`
-
-ℹ Fix
-109 109 | 
-110 110 | match *0, 1, *2:
-111 111 |     case 0,:
-112     |-        import b1
-113 112 | 
-114 113 |         import b2
-
-F401_0.py:114:16: F401 [*] `b2` imported but unused
-    |
-112 |         import b1
-113 | 
-114 |         import b2
-    |                ^^ F401
-    |
-    = help: Remove unused import: `b2`
-
-ℹ Fix
-111 111 |     case 0,:
-112 112 |         import b1
-113 113 | 
-114     |-        import b2
 
 

crates/ruff/src/rules/pyflakes/snapshots/ruff__rules__pyflakes__tests__F522_F522.py.snap

@@ -33,7 +33,7 @@ F522.py:2:1: F522 [*] `.format` call has unused named argument(s): spam
   2 |+"{bar}{}".format(1, bar=2, )  # F522
 3 3 | "{bar:{spam}}".format(bar=2, spam=3)  # No issues
 4 4 | "{bar:{spam}}".format(bar=2, spam=3, eggs=4, ham=5)  # F522
-5 5 | (''
+5 5 | # Not fixable
 
 F522.py:4:1: F522 [*] `.format` call has unused named argument(s): eggs, ham
   |
@@ -41,8 +41,8 @@ F522.py:4:1: F522 [*] `.format` call has unused named argument(s): eggs, ham
 3 | "{bar:{spam}}".format(bar=2, spam=3)  # No issues
 4 | "{bar:{spam}}".format(bar=2, spam=3, eggs=4, ham=5)  # F522
   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ F522
-5 | (''
-6 |  .format(x=2))  # F522
+5 | # Not fixable
+6 | (''
   |
   = help: Remove extra named arguments: eggs, ham
 
@@ -52,25 +52,19 @@ F522.py:4:1: F522 [*] `.format` call has unused named argument(s): eggs, ham
 3 3 | "{bar:{spam}}".format(bar=2, spam=3)  # No issues
 4   |-"{bar:{spam}}".format(bar=2, spam=3, eggs=4, ham=5)  # F522
   4 |+"{bar:{spam}}".format(bar=2, spam=3, )  # F522
-5 5 | (''
-6 6 |  .format(x=2))  # F522
+5 5 | # Not fixable
+6 6 | (''
+7 7 |  .format(x=2))
 
-F522.py:5:2: F522 [*] `.format` call has unused named argument(s): x
+F522.py:6:2: F522 `.format` call has unused named argument(s): x
   |
-3 |   "{bar:{spam}}".format(bar=2, spam=3)  # No issues
 4 |   "{bar:{spam}}".format(bar=2, spam=3, eggs=4, ham=5)  # F522
-5 |   (''
+5 |   # Not fixable
+6 |   (''
   |  __^
-6 | |  .format(x=2))  # F522
+7 | |  .format(x=2))
   | |_____________^ F522
   |
   = help: Remove extra named arguments: x
 
-ℹ Fix
-3 3 | "{bar:{spam}}".format(bar=2, spam=3)  # No issues
-4 4 | "{bar:{spam}}".format(bar=2, spam=3, eggs=4, ham=5)  # F522
-5 5 | (''
-6   |- .format(x=2))  # F522
-  6 |+ .format())  # F522
-
 

crates/ruff/src/rules/pyflakes/snapshots/ruff__rules__pyflakes__tests__F523_F523.py.snap

@@ -243,13 +243,13 @@ F523.py:29:1: F523 `.format` call has unused arguments at position(s): 0
 29 | "{1} {8}".format(0, 1)  # F523, # F524
    | ^^^^^^^^^^^^^^^^^^^^^^ F523
 30 | 
-31 | # Multiline
+31 | # Not fixable
    |
    = help: Remove extra positional arguments at position(s): 0
 
-F523.py:32:2: F523 [*] `.format` call has unused arguments at position(s): 0
+F523.py:32:2: F523 `.format` call has unused arguments at position(s): 0
    |
-31 |   # Multiline
+31 |   # Not fixable
 32 |   (''
    |  __^
 33 | | .format(2))
@@ -257,11 +257,4 @@ F523.py:32:2: F523 [*] `.format` call has unused arguments at position(s): 0
    |
    = help: Remove extra positional arguments at position(s): 0
 
-ℹ Fix
-30 30 | 
-31 31 | # Multiline
-32 32 | (''
-33    |-.format(2))
-   33 |+.format())
-
 

crates/ruff/src/rules/pyflakes/snapshots/ruff__rules__pyflakes__tests__F841_F841_3.py.snap

@@ -601,76 +601,5 @@ F841_3.py:155:17: F841 [*] Local variable `e` is assigned to but never used
 155     |-    except A as e :
     155 |+    except A:
 156 156 |         print("oh no!")
-157 157 | 
-158 158 | 
-
-F841_3.py:160:5: F841 [*] Local variable `x` is assigned to but never used
-    |
-159 | def f():
-160 |     x = 1
-    |     ^ F841
-161 |     y = 2
-    |
-    = help: Remove assignment to unused variable `x`
-
-ℹ Suggested fix
-157 157 | 
-158 158 | 
-159 159 | def f():
-160     |-    x = 1
-161 160 |     y = 2
-162 161 | 
-163 162 | 
-
-F841_3.py:161:5: F841 [*] Local variable `y` is assigned to but never used
-    |
-159 | def f():
-160 |     x = 1
-161 |     y = 2
-    |     ^ F841
-    |
-    = help: Remove assignment to unused variable `y`
-
-ℹ Suggested fix
-158 158 | 
-159 159 | def f():
-160 160 |     x = 1
-161     |-    y = 2
-162 161 | 
-163 162 | 
-164 163 | def f():
-
-F841_3.py:165:5: F841 [*] Local variable `x` is assigned to but never used
-    |
-164 | def f():
-165 |     x = 1
-    |     ^ F841
-166 | 
-167 |     y = 2
-    |
-    = help: Remove assignment to unused variable `x`
-
-ℹ Suggested fix
-162 162 | 
-163 163 | 
-164 164 | def f():
-165     |-    x = 1
-166 165 | 
-167 166 |     y = 2
-
-F841_3.py:167:5: F841 [*] Local variable `y` is assigned to but never used
-    |
-165 |     x = 1
-166 | 
-167 |     y = 2
-    |     ^ F841
-    |
-    = help: Remove assignment to unused variable `y`
-
-ℹ Suggested fix
-164 164 | def f():
-165 165 |     x = 1
-166 166 | 
-167     |-    y = 2
 
 

crates/ruff/src/rules/pylint/rules/repeated_equality_comparison_target.rs

@@ -2,16 +2,15 @@ use std::hash::BuildHasherDefault;
 use std::ops::Deref;
 
 use itertools::{any, Itertools};
+use ruff_python_ast::{BoolOp, CmpOp, Expr, ExprBoolOp, ExprCompare, Ranged};
 use rustc_hash::FxHashMap;
 
+use crate::autofix::snippet::SourceCodeSnippet;
 use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};
-use ruff_python_ast::comparable::ComparableExpr;
 use ruff_python_ast::hashable::HashableExpr;
-use ruff_python_ast::{self as ast, BoolOp, CmpOp, Expr, Ranged};
 use ruff_source_file::Locator;
 
-use crate::autofix::snippet::SourceCodeSnippet;
 use crate::checkers::ast::Checker;
 
 /// ## What it does
@@ -64,10 +63,7 @@ impl Violation for RepeatedEqualityComparisonTarget {
 }
 
 /// PLR1714
-pub(crate) fn repeated_equality_comparison_target(
-    checker: &mut Checker,
-    bool_op: &ast::ExprBoolOp,
-) {
+pub(crate) fn repeated_equality_comparison_target(checker: &mut Checker, bool_op: &ExprBoolOp) {
     if bool_op
         .values
         .iter()
@@ -76,49 +72,27 @@ pub(crate) fn repeated_equality_comparison_target(
         return;
     }
 
-    let mut value_to_comparators: FxHashMap<HashableExpr, (usize, Vec<&Expr>)> =
-        FxHashMap::with_capacity_and_hasher(
-            bool_op.values.len() * 2,
-            BuildHasherDefault::default(),
-        );
-
+    let mut left_to_comparators: FxHashMap<HashableExpr, (usize, Vec<&Expr>)> =
+        FxHashMap::with_capacity_and_hasher(bool_op.values.len(), BuildHasherDefault::default());
     for value in &bool_op.values {
-        // Enforced via `is_allowed_value`.
-        let Expr::Compare(ast::ExprCompare {
+        if let Expr::Compare(ExprCompare {
             left, comparators, ..
         }) = value
-        else {
-            return;
-        };
-
-        // Enforced via `is_allowed_value`.
-        let [right] = comparators.as_slice() else {
-            return;
-        };
-
-        if matches!(left.as_ref(), Expr::Name(_) | Expr::Attribute(_)) {
-            let (left_count, left_matches) = value_to_comparators
+        {
+            let (count, matches) = left_to_comparators
                 .entry(left.deref().into())
                 .or_insert_with(|| (0, Vec::new()));
-            *left_count += 1;
-            left_matches.push(right);
-        }
-
-        if matches!(right, Expr::Name(_) | Expr::Attribute(_)) {
-            let (right_count, right_matches) = value_to_comparators
-                .entry(right.into())
-                .or_insert_with(|| (0, Vec::new()));
-            *right_count += 1;
-            right_matches.push(left);
+            *count += 1;
+            matches.extend(comparators);
         }
     }
 
-    for (value, (count, comparators)) in value_to_comparators {
+    for (left, (count, comparators)) in left_to_comparators {
         if count > 1 {
             checker.diagnostics.push(Diagnostic::new(
                 RepeatedEqualityComparisonTarget {
                     expression: SourceCodeSnippet::new(merged_membership_test(
-                        value.as_expr(),
+                        left.as_expr(),
                         bool_op.op,
                         &comparators,
                         checker.locator(),
@@ -134,7 +108,7 @@ pub(crate) fn repeated_equality_comparison_target(
 /// E.g., `==` operators can be joined with `or` and `!=` operators can be
 /// joined with `and`.
 fn is_allowed_value(bool_op: BoolOp, value: &Expr) -> bool {
-    let Expr::Compare(ast::ExprCompare {
+    let Expr::Compare(ExprCompare {
         left,
         ops,
         comparators,
@@ -156,14 +130,6 @@ fn is_allowed_value(bool_op: BoolOp, value: &Expr) -> bool {
         return false;
     }
 
-    // Ignore self-comparisons, e.g., `foo == foo`.
-    let [right] = comparators.as_slice() else {
-        return false;
-    };
-    if ComparableExpr::from(left) == ComparableExpr::from(right) {
-        return false;
-    }
-
     if left.is_call_expr() {
         return false;
     }

crates/ruff/src/rules/pylint/rules/useless_return.rs

@@ -109,9 +109,7 @@ pub(crate) fn useless_return(
             checker.locator(),
             checker.indexer(),
         );
-        diagnostic.set_fix(Fix::automatic(edit).isolate(Checker::isolation(Some(
-            checker.semantic().current_statement_id(),
-        ))));
+        diagnostic.set_fix(Fix::automatic(edit).isolate(checker.statement_isolation()));
     }
     checker.diagnostics.push(diagnostic);
 }

crates/ruff/src/rules/pylint/snapshots/ruff__rules__pylint__tests__PLE1300_bad_string_format_character.py.snap

@@ -51,14 +51,24 @@ bad_string_format_character.py:15:1: PLE1300 Unsupported format character 'y'
 17 | "{:*^30s}".format("centered") # OK
    |
 
-bad_string_format_character.py:20:1: PLE1300 Unsupported format character 'y'
+bad_string_format_character.py:19:1: PLE1300 Unsupported format character 'y'
    |
+17 | "{:*^30s}".format("centered") # OK
 18 | "{:{s}}".format("hello", s="s")  # OK (nested replacement value not checked)
-19 | 
-20 | "{:{s:y}}".format("hello", s="s")  # [bad-format-character] (nested replacement format spec checked)
+19 | "{:{s:y}}".format("hello", s="s")  # [bad-format-character] (nested replacement format spec checked)
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ PLE1300
-21 | 
-22 | ## f-strings
+20 | "{0:.{prec}g}".format(1.23, prec=15)  # OK
+21 | "{0:.{foo}x{bar}y{foobar}g}".format(...)  # OK (all nested replacements are consumed without considering in between chars)
+   |
+
+bad_string_format_character.py:22:1: PLE1300 Unsupported format character 'y'
+   |
+20 | "{0:.{prec}g}".format(1.23, prec=15)  # OK
+21 | "{0:.{foo}x{bar}y{foobar}g}".format(...)  # OK (all nested replacements are consumed without considering in between chars)
+22 | "{0:.{foo}{bar}{foobar}y}".format(...)  # [bad-format-character] (check value after replacements)
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ PLE1300
+23 | 
+24 | ## f-strings
    |
 
 

crates/ruff/src/rules/pylint/snapshots/ruff__rules__pylint__tests__PLR1714_repeated_equality_comparison_target.py.snap

@@ -47,97 +47,7 @@ repeated_equality_comparison_target.py:10:1: PLR1714 Consider merging multiple c
 10 | foo == a or foo == "b" or foo == 3  # Mixed types.
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ PLR1714
 11 | 
-12 | "a" == foo or "b" == foo or "c" == foo
-   |
-
-repeated_equality_comparison_target.py:12:1: PLR1714 Consider merging multiple comparisons: `foo in ("a", "b", "c")`. Use a `set` if the elements are hashable.
-   |
-10 | foo == a or foo == "b" or foo == 3  # Mixed types.
-11 | 
-12 | "a" == foo or "b" == foo or "c" == foo
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ PLR1714
-13 | 
-14 | "a" != foo and "b" != foo and "c" != foo
-   |
-
-repeated_equality_comparison_target.py:14:1: PLR1714 Consider merging multiple comparisons: `foo not in ("a", "b", "c")`. Use a `set` if the elements are hashable.
-   |
-12 | "a" == foo or "b" == foo or "c" == foo
-13 | 
-14 | "a" != foo and "b" != foo and "c" != foo
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ PLR1714
-15 | 
-16 | "a" == foo or foo == "b" or "c" == foo
-   |
-
-repeated_equality_comparison_target.py:16:1: PLR1714 Consider merging multiple comparisons: `foo in ("a", "b", "c")`. Use a `set` if the elements are hashable.
-   |
-14 | "a" != foo and "b" != foo and "c" != foo
-15 | 
-16 | "a" == foo or foo == "b" or "c" == foo
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ PLR1714
-17 | 
-18 | foo == bar or baz == foo or qux == foo
-   |
-
-repeated_equality_comparison_target.py:18:1: PLR1714 Consider merging multiple comparisons: `foo in (bar, baz, qux)`. Use a `set` if the elements are hashable.
-   |
-16 | "a" == foo or foo == "b" or "c" == foo
-17 | 
-18 | foo == bar or baz == foo or qux == foo
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ PLR1714
-19 | 
-20 | foo == "a" or "b" == foo or foo == "c"
-   |
-
-repeated_equality_comparison_target.py:20:1: PLR1714 Consider merging multiple comparisons: `foo in ("a", "b", "c")`. Use a `set` if the elements are hashable.
-   |
-18 | foo == bar or baz == foo or qux == foo
-19 | 
-20 | foo == "a" or "b" == foo or foo == "c"
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ PLR1714
-21 | 
-22 | foo != "a" and "b" != foo and foo != "c"
-   |
-
-repeated_equality_comparison_target.py:22:1: PLR1714 Consider merging multiple comparisons: `foo not in ("a", "b", "c")`. Use a `set` if the elements are hashable.
-   |
-20 | foo == "a" or "b" == foo or foo == "c"
-21 | 
-22 | foo != "a" and "b" != foo and foo != "c"
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ PLR1714
-23 | 
-24 | foo == "a" or foo == "b" or "c" == bar or "d" == bar  # Multiple targets
-   |
-
-repeated_equality_comparison_target.py:24:1: PLR1714 Consider merging multiple comparisons: `foo in ("a", "b")`. Use a `set` if the elements are hashable.
-   |
-22 | foo != "a" and "b" != foo and foo != "c"
-23 | 
-24 | foo == "a" or foo == "b" or "c" == bar or "d" == bar  # Multiple targets
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ PLR1714
-25 | 
-26 | foo.bar == "a" or foo.bar == "b"  # Attributes.
-   |
-
-repeated_equality_comparison_target.py:24:1: PLR1714 Consider merging multiple comparisons: `bar in ("c", "d")`. Use a `set` if the elements are hashable.
-   |
-22 | foo != "a" and "b" != foo and foo != "c"
-23 | 
-24 | foo == "a" or foo == "b" or "c" == bar or "d" == bar  # Multiple targets
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ PLR1714
-25 | 
-26 | foo.bar == "a" or foo.bar == "b"  # Attributes.
-   |
-
-repeated_equality_comparison_target.py:26:1: PLR1714 Consider merging multiple comparisons: `foo.bar in ("a", "b")`. Use a `set` if the elements are hashable.
-   |
-24 | foo == "a" or foo == "b" or "c" == bar or "d" == bar  # Multiple targets
-25 | 
-26 | foo.bar == "a" or foo.bar == "b"  # Attributes.
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ PLR1714
-27 | 
-28 | # OK
+12 | # False negatives (the current implementation doesn't support Yoda conditions).
    |
 
 

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

@@ -67,11 +67,6 @@ mod tests {
     #[test_case(Rule::UTF8EncodingDeclaration, Path::new("UP009_3.py"))]
     #[test_case(Rule::UTF8EncodingDeclaration, Path::new("UP009_4.py"))]
     #[test_case(Rule::UTF8EncodingDeclaration, Path::new("UP009_5.py"))]
-    #[test_case(Rule::UTF8EncodingDeclaration, Path::new("UP009_6.py"))]
-    #[test_case(Rule::UTF8EncodingDeclaration, Path::new("UP009_7.py"))]
-    #[test_case(Rule::UTF8EncodingDeclaration, Path::new("UP009_8.py"))]
-    #[test_case(Rule::UTF8EncodingDeclaration, Path::new("UP009_9.py"))]
-    #[test_case(Rule::UTF8EncodingDeclaration, Path::new("UP009_10.py"))]
     #[test_case(Rule::UnicodeKindPrefix, Path::new("UP025.py"))]
     #[test_case(Rule::UnnecessaryBuiltinImport, Path::new("UP029.py"))]
     #[test_case(Rule::UnnecessaryClassParentheses, Path::new("UP039.py"))]

crates/ruff/src/rules/pyupgrade/rules/deprecated_mock_import.rs

@@ -335,10 +335,10 @@ pub(crate) fn deprecated_mock_import(checker: &mut Checker, stmt: &Stmt) {
                 );
                 if checker.patch(diagnostic.kind.rule()) {
                     if let Some(indent) = indentation(checker.locator(), stmt) {
-                        diagnostic.try_set_fix(|| {
+                        #[allow(deprecated)]
+                        diagnostic.try_set_fix_from_edit(|| {
                             format_import_from(stmt, indent, checker.locator(), checker.stylist())
                                 .map(|content| Edit::range_replacement(content, stmt.range()))
-                                .map(Fix::suggested)
                         });
                     }
                 }

crates/ruff/src/rules/pyupgrade/rules/f_strings.rs

@@ -1,18 +1,18 @@
 use std::borrow::Cow;
 
 use anyhow::{Context, Result};
+use ruff_python_ast::{self as ast, Arguments, Constant, Expr, Keyword, Ranged};
+use ruff_python_literal::format::{
+    FieldName, FieldNamePart, FieldType, FormatPart, FormatString, FromTemplate,
+};
+use ruff_python_parser::{lexer, Mode, Tok};
+use ruff_text_size::TextRange;
 use rustc_hash::FxHashMap;
 
 use ruff_diagnostics::{AutofixKind, Diagnostic, Edit, Fix, Violation};
 use ruff_macros::{derive_message_formats, violation};
 use ruff_python_ast::str::{leading_quote, trailing_quote};
-use ruff_python_ast::{self as ast, Constant, Expr, Keyword, Ranged};
-use ruff_python_literal::format::{
-    FieldName, FieldNamePart, FieldType, FormatPart, FormatString, FromTemplate,
-};
-use ruff_python_parser::{lexer, Mode, Tok};
 use ruff_source_file::Locator;
-use ruff_text_size::TextRange;
 
 use crate::checkers::ast::Checker;
 use crate::line_width::LineLength;
@@ -67,34 +67,39 @@ struct FormatSummaryValues<'a> {
 }
 
 impl<'a> FormatSummaryValues<'a> {
-    fn try_from_call(call: &'a ast::ExprCall, locator: &'a Locator) -> Option<Self> {
+    fn try_from_expr(expr: &'a Expr, locator: &'a Locator) -> Option<Self> {
         let mut extracted_args: Vec<&Expr> = Vec::new();
         let mut extracted_kwargs: FxHashMap<&str, &Expr> = FxHashMap::default();
-
-        for arg in &call.arguments.args {
-            if matches!(arg, Expr::Starred(..))
-                || contains_quotes(locator.slice(arg.range()))
-                || locator.contains_line_break(arg.range())
-            {
-                return None;
+        if let Expr::Call(ast::ExprCall {
+            arguments: Arguments { args, keywords, .. },
+            ..
+        }) = expr
+        {
+            for arg in args {
+                if matches!(arg, Expr::Starred(..))
+                    || contains_quotes(locator.slice(arg.range()))
+                    || locator.contains_line_break(arg.range())
+                {
+                    return None;
+                }
+                extracted_args.push(arg);
             }
-            extracted_args.push(arg);
-        }
-        for keyword in &call.arguments.keywords {
-            let Keyword {
-                arg,
-                value,
-                range: _,
-            } = keyword;
-            let Some(key) = arg else {
-                return None;
-            };
-            if contains_quotes(locator.slice(value.range()))
-                || locator.contains_line_break(value.range())
-            {
-                return None;
+            for keyword in keywords {
+                let Keyword {
+                    arg,
+                    value,
+                    range: _,
+                } = keyword;
+                let Some(key) = arg else {
+                    return None;
+                };
+                if contains_quotes(locator.slice(value.range()))
+                    || locator.contains_line_break(value.range())
+                {
+                    return None;
+                }
+                extracted_kwargs.insert(key, value);
             }
-            extracted_kwargs.insert(key, value);
         }
 
         if extracted_args.is_empty() && extracted_kwargs.is_empty() {
@@ -304,8 +309,8 @@ fn try_convert_to_f_string(
 /// UP032
 pub(crate) fn f_strings(
     checker: &mut Checker,
-    call: &ast::ExprCall,
     summary: &FormatSummary,
+    expr: &Expr,
     template: &Expr,
     line_length: LineLength,
 ) {
@@ -313,7 +318,14 @@ pub(crate) fn f_strings(
         return;
     }
 
-    let Expr::Attribute(ast::ExprAttribute { value, .. }) = call.func.as_ref() else {
+    let Expr::Call(ast::ExprCall {
+        func, arguments, ..
+    }) = expr
+    else {
+        return;
+    };
+
+    let Expr::Attribute(ast::ExprAttribute { value, .. }) = func.as_ref() else {
         return;
     };
 
@@ -327,14 +339,14 @@ pub(crate) fn f_strings(
         return;
     };
 
-    let Some(mut summary) = FormatSummaryValues::try_from_call(call, checker.locator()) else {
+    let Some(mut summary) = FormatSummaryValues::try_from_expr(expr, checker.locator()) else {
         return;
     };
     let mut patches: Vec<(TextRange, String)> = vec![];
     let mut lex = lexer::lex_starts_at(
-        checker.locator().slice(call.func.range()),
+        checker.locator().slice(func.range()),
         Mode::Expression,
-        call.start(),
+        expr.start(),
     )
     .flatten();
     let end = loop {
@@ -372,8 +384,8 @@ pub(crate) fn f_strings(
         return;
     }
 
-    let mut contents = String::with_capacity(checker.locator().slice(call.range()).len());
-    let mut prev_end = call.start();
+    let mut contents = String::with_capacity(checker.locator().slice(expr.range()).len());
+    let mut prev_end = expr.start();
     for (range, fstring) in patches {
         contents.push_str(
             checker
@@ -403,7 +415,7 @@ pub(crate) fn f_strings(
 
     // If necessary, add a space between any leading keyword (`return`, `yield`, `assert`, etc.)
     // and the string. For example, `return"foo"` is valid, but `returnf"foo"` is not.
-    let existing = checker.locator().slice(TextRange::up_to(call.start()));
+    let existing = checker.locator().slice(TextRange::up_to(expr.start()));
     if existing
         .chars()
         .last()
@@ -412,7 +424,7 @@ pub(crate) fn f_strings(
         contents.insert(0, ' ');
     }
 
-    let mut diagnostic = Diagnostic::new(FString, call.range());
+    let mut diagnostic = Diagnostic::new(FString, expr.range());
 
     // Avoid autofix if there are comments within the call:
     // ```
@@ -424,11 +436,11 @@ pub(crate) fn f_strings(
         && !checker
             .indexer()
             .comment_ranges()
-            .intersects(call.arguments.range())
+            .intersects(arguments.range())
     {
         diagnostic.set_fix(Fix::suggested(Edit::range_replacement(
             contents,
-            call.range(),
+            expr.range(),
         )));
     };
     checker.diagnostics.push(diagnostic);

crates/ruff/src/rules/pyupgrade/rules/format_literals.rs

@@ -2,18 +2,16 @@ use anyhow::{anyhow, Result};
 use libcst_native::{Arg, Expression};
 use once_cell::sync::Lazy;
 use regex::Regex;
+use ruff_python_ast::{self as ast, Expr, Ranged};
 
 use ruff_diagnostics::{AutofixKind, Diagnostic, Edit, Fix, Violation};
 use ruff_macros::{derive_message_formats, violation};
-use ruff_python_ast::{self as ast, Expr, Ranged};
 use ruff_python_codegen::Stylist;
 use ruff_source_file::Locator;
 
 use crate::autofix::codemods::CodegenStylist;
 use crate::checkers::ast::Checker;
-use crate::cst::matchers::{
-    match_attribute, match_call_mut, match_expression, transform_expression_text,
-};
+use crate::cst::matchers::{match_attribute, match_call_mut, match_expression};
 use crate::registry::AsRule;
 use crate::rules::pyflakes::format::FormatSummary;
 
@@ -60,8 +58,8 @@ impl Violation for FormatLiterals {
 /// UP030
 pub(crate) fn format_literals(
     checker: &mut Checker,
-    call: &ast::ExprCall,
     summary: &FormatSummary,
+    call: &ast::ExprCall,
 ) {
     // The format we expect is, e.g.: `"{0} {1}".format(...)`
     if summary.has_nested_parts {
@@ -114,8 +112,10 @@ pub(crate) fn format_literals(
     let mut diagnostic = Diagnostic::new(FormatLiterals, call.range());
     if checker.patch(diagnostic.kind.rule()) {
         diagnostic.try_set_fix(|| {
-            generate_call(call, arguments, checker.locator(), checker.stylist())
-                .map(|suggestion| Fix::suggested(Edit::range_replacement(suggestion, call.range())))
+            Ok(Fix::suggested(Edit::range_replacement(
+                generate_call(call, arguments, checker.locator(), checker.stylist())?,
+                call.range(),
+            )))
         });
     }
     checker.diagnostics.push(diagnostic);
@@ -165,7 +165,7 @@ fn remove_specifiers<'a>(value: &mut Expression<'a>, arena: &'a typed_arena::Are
 }
 
 /// Return the corrected argument vector.
-fn generate_arguments<'a>(arguments: &[Arg<'a>], order: &[usize]) -> Result<Vec<Arg<'a>>> {
+fn generate_arguments<'a>(arguments: &[Arg<'a>], order: &'a [usize]) -> Result<Vec<Arg<'a>>> {
     let mut new_arguments: Vec<Arg> = Vec::with_capacity(arguments.len());
     for (idx, given) in order.iter().enumerate() {
         // We need to keep the formatting in the same order but move the values.
@@ -205,27 +205,28 @@ fn generate_call(
     locator: &Locator,
     stylist: &Stylist,
 ) -> Result<String> {
-    let source_code = locator.slice(call.range());
+    let content = locator.slice(call.range());
+    let parenthesized_content = format!("({content})");
+    let mut expression = match_expression(&parenthesized_content)?;
 
-    let output = transform_expression_text(source_code, |source_code| {
-        let mut expression = match_expression(&source_code)?;
+    // Fix the call arguments.
+    let call = match_call_mut(&mut expression)?;
+    if let Arguments::Reorder(order) = arguments {
+        call.args = generate_arguments(&call.args, order)?;
+    }
 
-        // Fix the call arguments.
-        let call = match_call_mut(&mut expression)?;
-        if let Arguments::Reorder(order) = arguments {
-            call.args = generate_arguments(&call.args, order)?;
-        }
+    // Fix the string itself.
+    let item = match_attribute(&mut call.func)?;
+    let arena = typed_arena::Arena::new();
+    remove_specifiers(&mut item.value, &arena);
 
-        // Fix the string itself.
-        let item = match_attribute(&mut call.func)?;
-        let arena = typed_arena::Arena::new();
-        remove_specifiers(&mut item.value, &arena);
-
-        Ok(expression.codegen_stylist(stylist))
-    })?;
+    // Remove the parentheses (first and last characters).
+    let mut output = expression.codegen_stylist(stylist);
+    output.remove(0);
+    output.pop();
 
     // Ex) `'{' '0}'.format(1)`
-    if output == source_code {
+    if output == content {
         return Err(anyhow!("Unable to identify format literals"));
     }
 

crates/ruff/src/rules/pyupgrade/rules/lru_cache_without_parameters.rs

@@ -78,7 +78,10 @@ pub(crate) fn lru_cache_without_parameters(checker: &mut Checker, decorator_list
                 TextRange::new(func.end(), decorator.end()),
             );
             if checker.patch(diagnostic.kind.rule()) {
-                diagnostic.set_fix(Fix::automatic(Edit::range_deletion(arguments.range())));
+                diagnostic.set_fix(Fix::automatic(Edit::deletion(
+                    arguments.start(),
+                    arguments.end(),
+                )));
             }
             checker.diagnostics.push(diagnostic);
         }

crates/ruff/src/rules/pyupgrade/rules/native_literals.rs

@@ -5,7 +5,7 @@ use num_bigint::BigInt;
 
 use ruff_diagnostics::{AlwaysAutofixableViolation, Diagnostic, Edit, Fix};
 use ruff_macros::{derive_message_formats, violation};
-use ruff_python_ast::{self as ast, Constant, Expr, Ranged};
+use ruff_python_ast::{self as ast, Constant, Expr, Keyword, Ranged};
 
 use crate::checkers::ast::Checker;
 use crate::registry::AsRule;
@@ -129,21 +129,12 @@ impl AlwaysAutofixableViolation for NativeLiterals {
 /// UP018
 pub(crate) fn native_literals(
     checker: &mut Checker,
-    call: &ast::ExprCall,
-    parent_expr: Option<&ast::Expr>,
+    expr: &Expr,
+    func: &Expr,
+    args: &[Expr],
+    keywords: &[Keyword],
 ) {
-    let ast::ExprCall {
-        func,
-        arguments:
-            ast::Arguments {
-                args,
-                keywords,
-                range: _,
-            },
-        range: _,
-    } = call;
-
-    let Expr::Name(ast::ExprName { ref id, .. }) = func.as_ref() else {
+    let Expr::Name(ast::ExprName { id, .. }) = func else {
         return;
     };
 
@@ -174,20 +165,13 @@ pub(crate) fn native_literals(
 
     match args.get(0) {
         None => {
-            let mut diagnostic = Diagnostic::new(NativeLiterals { literal_type }, call.range());
-
-            // Do not suggest fix for attribute access on an int like `int().attribute`
-            // Ex) `int().denominator` is valid but `0.denominator` is not
-            if literal_type == LiteralType::Int && matches!(parent_expr, Some(Expr::Attribute(_))) {
-                return;
-            }
-
+            let mut diagnostic = Diagnostic::new(NativeLiterals { literal_type }, expr.range());
             if checker.patch(diagnostic.kind.rule()) {
                 let constant = Constant::from(literal_type);
                 let content = checker.generator().constant(&constant);
                 diagnostic.set_fix(Fix::automatic(Edit::range_replacement(
                     content,
-                    call.range(),
+                    expr.range(),
                 )));
             }
             checker.diagnostics.push(diagnostic);
@@ -212,20 +196,11 @@ pub(crate) fn native_literals(
 
             let arg_code = checker.locator().slice(arg.range());
 
-            // Attribute access on an integer requires the integer to be parenthesized to disambiguate from a float
-            // Ex) `(7).denominator` is valid but `7.denominator` is not
-            // Note that floats do not have this problem
-            // Ex) `(1.0).real` is valid and `1.0.real` is too
-            let content = match (parent_expr, value) {
-                (Some(Expr::Attribute(_)), Constant::Int(_)) => format!("({arg_code})"),
-                _ => arg_code.to_string(),
-            };
-
-            let mut diagnostic = Diagnostic::new(NativeLiterals { literal_type }, call.range());
+            let mut diagnostic = Diagnostic::new(NativeLiterals { literal_type }, expr.range());
             if checker.patch(diagnostic.kind.rule()) {
                 diagnostic.set_fix(Fix::automatic(Edit::range_replacement(
-                    content,
-                    call.range(),
+                    arg_code.to_string(),
+                    expr.range(),
                 )));
             }
             checker.diagnostics.push(diagnostic);

crates/ruff/src/rules/pyupgrade/rules/unnecessary_builtin_import.rs

@@ -135,9 +135,7 @@ pub(crate) fn unnecessary_builtin_import(
                 checker.stylist(),
                 checker.indexer(),
             )?;
-            Ok(Fix::suggested(edit).isolate(Checker::isolation(
-                checker.semantic().current_statement_parent_id(),
-            )))
+            Ok(Fix::suggested(edit).isolate(checker.parent_isolation()))
         });
     }
     checker.diagnostics.push(diagnostic);

crates/ruff/src/rules/pyupgrade/rules/unnecessary_coding_comment.rs

@@ -5,7 +5,6 @@ use ruff_diagnostics::{AlwaysAutofixableViolation, Diagnostic, Edit, Fix};
 use ruff_macros::{derive_message_formats, violation};
 use ruff_python_index::Indexer;
 use ruff_source_file::Locator;
-use ruff_text_size::TextRange;
 
 use crate::registry::AsRule;
 use crate::settings::Settings;
@@ -56,45 +55,20 @@ pub(crate) fn unnecessary_coding_comment(
 ) {
     // The coding comment must be on one of the first two lines. Since each comment spans at least
     // one line, we only need to check the first two comments at most.
-    for comment_range in indexer.comment_ranges().iter().take(2) {
-        // If leading content is not whitespace then it's not a valid coding comment e.g.
-        // ```
-        // print(x) # coding=utf8
-        // ```
-        let line_range = locator.full_line_range(comment_range.start());
-        if !locator
-            .slice(TextRange::new(line_range.start(), comment_range.start()))
-            .trim()
-            .is_empty()
-        {
-            continue;
-        }
-
-        // If the line is after a continuation then it's not a valid coding comment e.g.
-        // ```
-        // x = 1 \
-        //    # coding=utf8
-        // x = 2
-        // ```
-        if indexer
-            .preceded_by_continuations(line_range.start(), locator)
-            .is_some()
-        {
-            continue;
-        }
-
-        if CODING_COMMENT_REGEX.is_match(locator.slice(line_range)) {
+    for range in indexer.comment_ranges().iter().take(2) {
+        let line = locator.slice(*range);
+        if CODING_COMMENT_REGEX.is_match(line) {
             #[allow(deprecated)]
-            let index = locator.compute_line_index(line_range.start());
-            if index.to_zero_indexed() > 1 {
+            let line = locator.compute_line_index(range.start());
+            if line.to_zero_indexed() > 1 {
                 continue;
             }
 
-            let mut diagnostic = Diagnostic::new(UTF8EncodingDeclaration, *comment_range);
+            let mut diagnostic = Diagnostic::new(UTF8EncodingDeclaration, *range);
             if settings.rules.should_fix(diagnostic.kind.rule()) {
                 diagnostic.set_fix(Fix::automatic(Edit::deletion(
-                    line_range.start(),
-                    line_range.end(),
+                    range.start(),
+                    locator.full_line_end(range.end()),
                 )));
             }
             diagnostics.push(diagnostic);

crates/ruff/src/rules/pyupgrade/rules/unnecessary_future_import.rs

@@ -124,9 +124,7 @@ pub(crate) fn unnecessary_future_import(checker: &mut Checker, stmt: &Stmt, name
                 checker.stylist(),
                 checker.indexer(),
             )?;
-            Ok(Fix::suggested(edit).isolate(Checker::isolation(
-                checker.semantic().current_statement_parent_id(),
-            )))
+            Ok(Fix::suggested(edit).isolate(checker.parent_isolation()))
         });
     }
     checker.diagnostics.push(diagnostic);

crates/ruff/src/rules/pyupgrade/rules/use_pep585_annotation.rs

@@ -20,16 +20,8 @@ use crate::registry::AsRule;
 ///
 /// When available, the [PEP 585] syntax should be used instead of importing
 /// members from the `typing` module, as it's more concise and readable.
-/// Importing those members from `typing` is considered deprecated as of [PEP
-/// 585].
-///
-/// This rule is enabled when targeting Python 3.9 or later (see:
-/// [`target-version`]). By default, it's _also_ enabled for earlier Python
-/// versions if `from __future__ import annotations` is present, as
-/// `__future__` annotations are not evaluated at runtime. If your code relies
-/// on runtime type annotations (either directly or via a library like
-/// Pydantic), you can disable this behavior for Python versions prior to 3.9
-/// by setting [`pyupgrade.keep-runtime-typing`] to `true`.
+/// Importing those members from `typing` is considered deprecated as of PEP
+/// 585.
 ///
 /// ## Example
 /// ```python