[pyflakes] Avoid removing the format call when it would change behavior (F523) (#25320)

## Summary

When every positional argument is unused, `F523` removes the entire
`.format(...)` call. That changes behavior whenever the format string
relies on the call:

* Brace escapes: `"{{".format("!")` returns `"{"`, but `"{{"` is two
characters.
* Named placeholders: `"{x}".format("!")` raises `KeyError`, but `"{x}"`
quietly succeeds.

This detects these cases and avoids removing the entire `format` call.
We also tried the "ideal" fix described on the issue of processing the
string to handle escapes ourselves, but just preserving the call seemed
like the better tradeoff in terms of complexity.

## Test plan

New mdtests based on the examples from the issue

Closes #15557

---------

Co-authored-by: Brent Westbrook <brentrwestbrook@gmail.com>

Author: adityasingh2400

crates/ruff_linter/resources/mdtest/pyflakes/string-dot-format-extra-positional-arguments.md

@@ -0,0 +1,44 @@
+# `string-dot-format-extra-positional-arguments` (`F523`)
+
+```toml
+[lint]
+select = ["F523"]
+```
+
+## Regression tests for [#15557]
+
+These should both trigger the rule, but their fixes should not remove the `format` call. In the
+first case, `format` will handle escaping `{{` to `{`, while in the second case, removing the
+`format` call would suppress a `KeyError`:
+
+```py
+print("{{".format("!"))  # snapshot: string-dot-format-extra-positional-arguments
+print("{x}".format("!"))  # snapshot: string-dot-format-extra-positional-arguments
+```
+
+```snapshot
+error[F523]: `.format` call has unused arguments at position(s): 0
+ --> src/mdtest_snippet.py:1:7
+  |
+1 | print("{{".format("!"))  # snapshot: string-dot-format-extra-positional-arguments
+  |       ^^^^^^^^^^^^^^^^
+  |
+help: Remove extra positional arguments at position(s): 0
+  - print("{{".format("!"))  # snapshot: string-dot-format-extra-positional-arguments
+1 + print("{{".format())  # snapshot: string-dot-format-extra-positional-arguments
+2 | print("{x}".format("!"))  # snapshot: string-dot-format-extra-positional-arguments
+
+
+error[F523]: `.format` call has unused arguments at position(s): 0
+ --> src/mdtest_snippet.py:2:7
+  |
+2 | print("{x}".format("!"))  # snapshot: string-dot-format-extra-positional-arguments
+  |       ^^^^^^^^^^^^^^^^^
+  |
+help: Remove extra positional arguments at position(s): 0
+1 | print("{{".format("!"))  # snapshot: string-dot-format-extra-positional-arguments
+  - print("{x}".format("!"))  # snapshot: string-dot-format-extra-positional-arguments
+2 + print("{x}".format())  # snapshot: string-dot-format-extra-positional-arguments
+```
+
+[#15557]: https://github.com/astral-sh/ruff/issues/15557

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

@@ -73,13 +73,18 @@ pub(crate) fn remove_unused_positional_arguments_from_format_call(
     // 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(),
-            ));
-        }
+    //
+    // However, if the `format` call has other effects, like escaping `{{` to `{` or would raise a
+    // `KeyError` for a missing field name, we preserve the empty call to avoid changing behavior.
+    if unused_arguments.len() == call.arguments.len()
+        && let Expr::Attribute(attribute) = &*call.func
+        && let Expr::StringLiteral(string_expr) = &*attribute.value
+        && !string_expr.value.to_str().contains(['{', '}'])
+    {
+        return Ok(Edit::range_replacement(
+            locator.slice(string_expr).to_string(),
+            call.range(),
+        ));
     }
 
     let source_code = locator.slice(call);
@@ -94,12 +99,7 @@ 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()))
 }