[pyflakes] Implement the ideal F523 fix when the .format call has no remaining replacement fields

When dropping every positional argument leaves a format string with only `{{` / `}}` brace escapes, the rewrite now removes the `.format(...)` call and reduces the escapes to single braces so the result matches what `.format()` would have produced. When the string still has replacement fields (auto, indexed, or named), the empty `.format()` call is kept so the runtime behaviour, including any `KeyError`, is preserved. Both branches are safe fixes again.

Author: adityasingh2400

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

@@ -43,3 +43,14 @@
 # The fix here is safe because the unused argument has no side effect,
 # even though the used argument has a side effect
 "Hello, {0}".format(print(1), "Pikachu")
+
+# https://github.com/astral-sh/ruff/issues/15557
+# When dropping every argument leaves a string with only `{{`/`}}` escapes, the
+# `.format(...)` call is removed and the escapes are reduced to single braces.
+# When the string still has replacement fields, the empty `.format()` call is
+# kept so the `KeyError` (or other failure) at runtime is preserved.
+"{{".format("!")
+"{x}".format("!")
+"{{}}".format("!")
+"{{0}}".format("!")
+"{x}".format("!", x=1)

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

@@ -10,6 +10,7 @@ use ruff_text_size::Ranged;
 use crate::Edit;
 use crate::Locator;
 use crate::cst::matchers::{match_call_mut, match_dict, transform_expression};
+use crate::rules::pyflakes::format::FormatSummary;
 
 /// Generate a [`Edit`] to remove unused keys from format dict.
 pub(super) fn remove_unused_format_arguments_from_dict(
@@ -64,22 +65,29 @@ pub(super) fn remove_unused_keyword_arguments_from_format_call(
 }
 
 /// Generate a [`Edit`] to remove unused positional arguments from a `format` call.
+///
+/// When the rewrite would leave `.format(...)` with zero arguments and the
+/// format string has no replacement fields, the call itself is dropped and any
+/// `{{` / `}}` escapes in the literal are reduced to single braces so the
+/// result matches what `.format()` would have produced. When the string still
+/// has replacement fields (or the literal cannot be unescaped textually) the
+/// empty `.format()` call is kept so that runtime behaviour, including any
+/// `KeyError`, is preserved.
 pub(crate) fn remove_unused_positional_arguments_from_format_call(
     unused_arguments: &[usize],
     call: &ast::ExprCall,
+    summary: &FormatSummary,
     locator: &Locator,
     stylist: &Stylist,
 ) -> Result<Edit> {
-    // If we're removing _all_ arguments, we can remove the entire call.
-    //
-    // For example, `"Hello".format(", world!")` -> `"Hello"`, as opposed to `"Hello".format()`.
-    if unused_arguments.len() == call.arguments.len() {
-        if let Expr::Attribute(attribute) = &*call.func {
-            return Ok(Edit::range_replacement(
-                locator.slice(&*attribute.value).to_string(),
-                call.range(),
-            ));
-        }
+    if unused_arguments.len() == call.arguments.len()
+        && summary.autos.is_empty()
+        && summary.indices.is_empty()
+        && summary.keywords.is_empty()
+        && let Expr::Attribute(attribute) = &*call.func
+        && let Some(replacement) = literal_source_without_format_call(&attribute.value, locator)
+    {
+        return Ok(Edit::range_replacement(replacement, call.range()));
     }
 
     let source_code = locator.slice(call);
@@ -94,16 +102,76 @@ pub(crate) fn remove_unused_positional_arguments_from_format_call(
             !is_unused
         });
 
-        // If there are no arguments left, remove the parentheses.
-        if call.args.is_empty() {
-            Ok((*call.func).clone())
-        } else {
-            Ok(expression)
-        }
+        Ok(expression)
     })
     .map(|output| Edit::range_replacement(output, call.range()))
 }
 
+/// Returns the source text to substitute for `expr.format(...)` when the
+/// `.format(...)` call is being dropped because it has no replacement fields
+/// and no remaining arguments.
+///
+/// Returns `None` when the rewrite cannot be done safely, in which case the
+/// caller should keep the `.format(...)` call (with no args) instead.
+///
+/// If the literal's decoded value has no braces, `.format()` is a no-op on it
+/// and the original source can be reused verbatim. When the value contains
+/// `{{` / `}}` escapes, those are reduced to single braces, but only when the
+/// literal's source content equals its decoded value: an escape such as
+/// `\x7b` could otherwise interact with a neighbouring literal brace and
+/// silently change the resulting string.
+fn literal_source_without_format_call(expr: &Expr, locator: &Locator) -> Option<String> {
+    let Expr::StringLiteral(string_expr) = expr else {
+        return None;
+    };
+    if string_expr.value.is_implicit_concatenated() {
+        return None;
+    }
+    let literal = string_expr.value.iter().next()?;
+
+    if !literal.value.contains(['{', '}']) {
+        // `.format()` would not have changed anything in the resulting
+        // string, so reuse the original source as-is.
+        return Some(locator.slice(string_expr).to_string());
+    }
+
+    let content_range = literal.content_range();
+    let source_content = locator.slice(content_range);
+
+    // The textual `{{` -> `{` rewrite below is only safe when the source
+    // content matches the decoded value: otherwise a Python escape sequence
+    // such as `\x7b` could combine with a neighbouring literal brace and
+    // change the resulting string.
+    if source_content != &*literal.value {
+        return None;
+    }
+
+    let unescaped = unescape_format_braces(source_content);
+    let prefix_and_opener = locator.slice(ruff_text_size::TextRange::new(
+        literal.start(),
+        content_range.start(),
+    ));
+    let closer = locator.slice(ruff_text_size::TextRange::new(
+        content_range.end(),
+        literal.end(),
+    ));
+
+    Some(format!("{prefix_and_opener}{unescaped}{closer}"))
+}
+
+/// Replaces every `{{` with `{` and every `}}` with `}` in `text`.
+fn unescape_format_braces(text: &str) -> String {
+    let mut out = String::with_capacity(text.len());
+    let mut chars = text.chars().peekable();
+    while let Some(ch) = chars.next() {
+        if (ch == '{' || ch == '}') && chars.peek() == Some(&ch) {
+            chars.next();
+        }
+        out.push(ch);
+    }
+    out
+}
+
 /// Generate a [`Edit`] to remove the binding from an exception handler.
 pub(crate) fn remove_exception_handler_assignment(
     bound_exception: &Binding,

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

@@ -924,6 +924,7 @@ pub(crate) fn string_dot_format_extra_positional_arguments(
             let edit = remove_unused_positional_arguments_from_format_call(
                 &missing,
                 call,
+                summary,
                 checker.locator(),
                 checker.stylist(),
             )?;

crates/ruff_linter/src/rules/pyflakes/snapshots/ruff_linter__rules__pyflakes__tests__F523_F523.py.snap

@@ -332,10 +332,106 @@ F523 [*] `.format` call has unused arguments at position(s): 1
 44 | # even though the used argument has a side effect
 45 | "Hello, {0}".format(print(1), "Pikachu")
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+46 |
+47 | # https://github.com/astral-sh/ruff/issues/15557
    |
 help: Remove extra positional arguments at position(s): 1
 42 |
 43 | # The fix here is safe because the unused argument has no side effect,
 44 | # even though the used argument has a side effect
    - "Hello, {0}".format(print(1), "Pikachu")
 45 + "Hello, {0}".format(print(1), )
+46 |
+47 | # https://github.com/astral-sh/ruff/issues/15557
+48 | # When dropping every argument leaves a string with only `{{`/`}}` escapes, the
+
+F523 [*] `.format` call has unused arguments at position(s): 0
+  --> F523.py:52:1
+   |
+50 | # When the string still has replacement fields, the empty `.format()` call is
+51 | # kept so the `KeyError` (or other failure) at runtime is preserved.
+52 | "{{".format("!")
+   | ^^^^^^^^^^^^^^^^
+53 | "{x}".format("!")
+54 | "{{}}".format("!")
+   |
+help: Remove extra positional arguments at position(s): 0
+49 | # `.format(...)` call is removed and the escapes are reduced to single braces.
+50 | # When the string still has replacement fields, the empty `.format()` call is
+51 | # kept so the `KeyError` (or other failure) at runtime is preserved.
+   - "{{".format("!")
+52 + "{"
+53 | "{x}".format("!")
+54 | "{{}}".format("!")
+55 | "{{0}}".format("!")
+
+F523 [*] `.format` call has unused arguments at position(s): 0
+  --> F523.py:53:1
+   |
+51 | # kept so the `KeyError` (or other failure) at runtime is preserved.
+52 | "{{".format("!")
+53 | "{x}".format("!")
+   | ^^^^^^^^^^^^^^^^^
+54 | "{{}}".format("!")
+55 | "{{0}}".format("!")
+   |
+help: Remove extra positional arguments at position(s): 0
+50 | # When the string still has replacement fields, the empty `.format()` call is
+51 | # kept so the `KeyError` (or other failure) at runtime is preserved.
+52 | "{{".format("!")
+   - "{x}".format("!")
+53 + "{x}".format()
+54 | "{{}}".format("!")
+55 | "{{0}}".format("!")
+56 | "{x}".format("!", x=1)
+
+F523 [*] `.format` call has unused arguments at position(s): 0
+  --> F523.py:54:1
+   |
+52 | "{{".format("!")
+53 | "{x}".format("!")
+54 | "{{}}".format("!")
+   | ^^^^^^^^^^^^^^^^^^
+55 | "{{0}}".format("!")
+56 | "{x}".format("!", x=1)
+   |
+help: Remove extra positional arguments at position(s): 0
+51 | # kept so the `KeyError` (or other failure) at runtime is preserved.
+52 | "{{".format("!")
+53 | "{x}".format("!")
+   - "{{}}".format("!")
+54 + "{}"
+55 | "{{0}}".format("!")
+56 | "{x}".format("!", x=1)
+
+F523 [*] `.format` call has unused arguments at position(s): 0
+  --> F523.py:55:1
+   |
+53 | "{x}".format("!")
+54 | "{{}}".format("!")
+55 | "{{0}}".format("!")
+   | ^^^^^^^^^^^^^^^^^^^
+56 | "{x}".format("!", x=1)
+   |
+help: Remove extra positional arguments at position(s): 0
+52 | "{{".format("!")
+53 | "{x}".format("!")
+54 | "{{}}".format("!")
+   - "{{0}}".format("!")
+55 + "{0}"
+56 | "{x}".format("!", x=1)
+
+F523 [*] `.format` call has unused arguments at position(s): 0
+  --> F523.py:56:1
+   |
+54 | "{{}}".format("!")
+55 | "{{0}}".format("!")
+56 | "{x}".format("!", x=1)
+   | ^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: Remove extra positional arguments at position(s): 0
+53 | "{x}".format("!")
+54 | "{{}}".format("!")
+55 | "{{0}}".format("!")
+   - "{x}".format("!", x=1)
+56 + "{x}".format(x=1)