[refurb] Mark autofix as safe only for number literals in FURB116 (astral-sh#17692)

<!--
Thank you for contributing to Ruff! To help us out with reviewing,
please consider the following:

- Does this pull request include a summary of the change? (See below.)
- Does this pull request include a descriptive title?
- Does this pull request include references to any relevant issues?
-->

## Summary
We can only guarantee the safety of the autofix for number literals, all
other cases may change the runtime behaviour of the program or introduce
a syntax error. For the cases reported in the issue that would result in
a syntax error, I disabled the autofix.

Follow-up of astral-sh#17661. 

Fixes astral-sh#16472.
<!-- What's the purpose of the change? What does it do, and why? -->

## Test Plan

Snapshot tests.
<!-- How was it tested? -->

Author: LaBatata101

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

@@ -1,3 +1,6 @@
+import datetime
+import sys
+
 num = 1337
 
 def return_num() -> int:
@@ -10,6 +13,7 @@ def return_num() -> int:
 print(oct(1337)[2:])  # FURB116
 print(hex(1337)[2:])  # FURB116
 print(bin(1337)[2:])  # FURB116
+print(bin(+1337)[2:])  # FURB116
 
 print(bin(return_num())[2:])  # FURB116 (no autofix)
 print(bin(int(f"{num}"))[2:])  # FURB116 (no autofix)
@@ -22,3 +26,19 @@ def return_num() -> int:
 # float and complex numbers should be ignored
 print(bin(1.0)[2:])
 print(bin(3.14j)[2:])
+
+d = datetime.datetime.now(tz=datetime.UTC)
+# autofix is display-only
+print(bin(d)[2:])
+# no autofix for Python 3.11 and earlier, as it introduces a syntax error
+print(bin(len("xyz").numerator)[2:])
+
+# autofix is display-only
+print(bin({0: 1}[0].numerator)[2:])
+# no autofix for Python 3.11 and earlier, as it introduces a syntax error
+print(bin(ord("\\").numerator)[2:])
+print(hex(sys
+.maxunicode)[2:])
+
+# for negatives numbers autofix is display-only
+print(bin(-1)[2:])

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

@@ -89,4 +89,15 @@ mod tests {
         assert_messages!(diagnostics);
         Ok(())
     }
+
+    #[test]
+    fn fstring_number_format_python_311() -> Result<()> {
+        let diagnostics = test_path(
+            Path::new("refurb/FURB116.py"),
+            &settings::LinterSettings::for_rule(Rule::FStringNumberFormat)
+                .with_target_version(PythonVersion::PY311),
+        )?;
+        assert_messages!(diagnostics);
+        Ok(())
+    }
 }

crates/ruff_linter/src/rules/refurb/rules/fstring_number_format.rs

@@ -1,6 +1,7 @@
-use ruff_diagnostics::{Diagnostic, Edit, Fix, FixAvailability, Violation};
+use ruff_diagnostics::{Applicability, Diagnostic, Edit, Fix, FixAvailability, Violation};
 use ruff_macros::{derive_message_formats, ViolationMetadata};
-use ruff_python_ast::{self as ast, Expr, ExprCall, Number};
+use ruff_python_ast::{self as ast, Expr, ExprCall, Number, PythonVersion, UnaryOp};
+use ruff_source_file::find_newline;
 use ruff_text_size::Ranged;
 
 use crate::checkers::ast::Checker;
@@ -24,6 +25,11 @@ use crate::fix::snippet::SourceCodeSnippet;
 /// ```python
 /// print(f"{1337:b}")
 /// ```
+///
+/// ## Fix safety
+/// The fix is only marked as safe for integer literals, all other cases
+/// are display-only, as they may change the runtime behaviour of the program
+/// or introduce syntax errors.
 #[derive(ViolationMetadata)]
 pub(crate) struct FStringNumberFormat {
     replacement: Option<SourceCodeSnippet>,
@@ -121,21 +127,24 @@ pub(crate) fn fstring_number_format(checker: &Checker, subscript: &ast::ExprSubs
         return;
     }
 
-    // Generate a replacement, if possible.
-    let replacement = if matches!(
-        arg,
-        Expr::NumberLiteral(_) | Expr::Name(_) | Expr::Attribute(_)
-    ) {
-        let inner_source = checker.locator().slice(arg);
-
-        let quote = checker.stylist().quote();
-        let shorthand = base.shorthand();
+    let maybe_number = if let Some(maybe_number) = arg
+        .as_unary_op_expr()
+        .filter(|unary_expr| unary_expr.op == UnaryOp::UAdd)
+        .map(|unary_expr| &unary_expr.operand)
+    {
+        maybe_number
+    } else {
+        arg
+    };
 
-        Some(format!("f{quote}{{{inner_source}:{shorthand}}}{quote}"))
+    let applicability = if matches!(maybe_number, Expr::NumberLiteral(_)) {
+        Applicability::Safe
     } else {
-        None
+        Applicability::DisplayOnly
     };
 
+    let replacement = try_create_replacement(checker, arg, base);
+
     let mut diagnostic = Diagnostic::new(
         FStringNumberFormat {
             replacement: replacement.as_deref().map(SourceCodeSnippet::from_str),
@@ -145,15 +154,54 @@ pub(crate) fn fstring_number_format(checker: &Checker, subscript: &ast::ExprSubs
     );
 
     if let Some(replacement) = replacement {
-        diagnostic.set_fix(Fix::safe_edit(Edit::range_replacement(
-            replacement,
-            subscript.range(),
-        )));
+        let edit = Edit::range_replacement(replacement, subscript.range());
+        diagnostic.set_fix(Fix::applicable_edit(edit, applicability));
     }
 
     checker.report_diagnostic(diagnostic);
 }
 
+/// Generate a replacement, if possible.
+fn try_create_replacement(checker: &Checker, arg: &Expr, base: Base) -> Option<String> {
+    if !matches!(
+        arg,
+        Expr::NumberLiteral(_) | Expr::Name(_) | Expr::Attribute(_) | Expr::UnaryOp(_)
+    ) {
+        return None;
+    }
+
+    let inner_source = checker.locator().slice(arg);
+
+    // On Python 3.11 and earlier, trying to replace an `arg` that contains a backslash
+    // would create a `SyntaxError` in the f-string.
+    if checker.target_version() <= PythonVersion::PY311 && inner_source.contains('\\') {
+        return None;
+    }
+
+    // On Python 3.11 and earlier, trying to replace an `arg` that spans multiple lines
+    // would create a `SyntaxError` in the f-string.
+    if checker.target_version() <= PythonVersion::PY311 && find_newline(inner_source).is_some() {
+        return None;
+    }
+
+    let quote = checker.stylist().quote();
+    let shorthand = base.shorthand();
+
+    // If the `arg` contains double quotes we need to create the f-string with single quotes
+    // to avoid a `SyntaxError` in Python 3.11 and earlier.
+    if checker.target_version() <= PythonVersion::PY311 && inner_source.contains(quote.as_str()) {
+        return None;
+    }
+
+    // If the `arg` contains a brace add an space before it to avoid a `SyntaxError`
+    // in the f-string.
+    if inner_source.starts_with('{') {
+        Some(format!("f{quote}{{ {inner_source}:{shorthand}}}{quote}"))
+    } else {
+        Some(format!("f{quote}{{{inner_source}:{shorthand}}}{quote}"))
+    }
+}
+
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
 enum Base {
     Hex,