fix: (UP032) Handle \N{...} in raw strings for f-string conversion

Author: denyszhak

crates/ruff_linter/resources/test/fixtures/pyupgrade/UP032_0.py

@@ -279,5 +279,5 @@ async def c():
 # Unicode escape in regular string, should convert.
 "\N{angle}AOB = {angle}°".format(angle=180)
 
-# Unicode escape in raw string, should not convert - would change semantics.
+# Raw string with \N{...} - both {angle} are format placeholders, should convert.
 r"\N{angle}AOB = {angle}°".format(angle=180)

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

@@ -8,9 +8,7 @@ use ruff_python_ast::helpers::any_over_expr;
 use ruff_python_ast::str::{leading_quote, trailing_quote};
 use ruff_python_ast::token::TokenKind;
 use ruff_python_ast::{self as ast, Expr, Keyword, StringFlags};
-use ruff_python_literal::format::{
-    FieldName, FieldNamePart, FieldType, FormatPart, FormatString, FromTemplate,
-};
+use ruff_python_literal::format::{FieldName, FieldNamePart, FieldType, FormatPart, FormatString};
 use ruff_source_file::LineRanges;
 use ruff_text_size::{Ranged, TextRange};
 
@@ -277,8 +275,8 @@ impl FStringConversion {
             return Ok(Self::EmptyLiteral);
         }
 
-        // Parse the format string.
-        let format_string = FormatString::from_str(contents)?;
+        // Parse the format string, passing raw flag to handle \N{...} correctly
+        let format_string = FormatString::parse(contents, raw)?;
 
         // If the format string contains only literal parts, it doesn't need to be converted.
         if format_string

crates/ruff_linter/src/rules/pyupgrade/snapshots/ruff_linter__rules__pyupgrade__tests__UP032_0.py.snap

@@ -1379,7 +1379,7 @@ UP032 [*] Use f-string instead of `format` call
 280 | "\N{angle}AOB = {angle}°".format(angle=180)
     | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 281 |
-282 | # Unicode escape in raw string, should not convert - would change semantics.
+282 | # Raw string with \N{...} - both {angle} are format placeholders, should convert.
     |
 help: Convert to f-string
 277 |     print(string)
@@ -1388,14 +1388,19 @@ help: Convert to f-string
     - "\N{angle}AOB = {angle}°".format(angle=180)
 280 + f"\N{angle}AOB = {180}°"
 281 | 
-282 | # Unicode escape in raw string, should not convert - would change semantics.
+282 | # Raw string with \N{...} - both {angle} are format placeholders, should convert.
 283 | r"\N{angle}AOB = {angle}°".format(angle=180)
 
-UP032 Use f-string instead of `format` call
+UP032 [*] Use f-string instead of `format` call
    --> UP032_0.py:283:1
     |
-282 | # Unicode escape in raw string, should not convert - would change semantics.
+282 | # Raw string with \N{...} - both {angle} are format placeholders, should convert.
 283 | r"\N{angle}AOB = {angle}°".format(angle=180)
     | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
     |
 help: Convert to f-string
+280 | "\N{angle}AOB = {angle}°".format(angle=180)
+281 | 
+282 | # Raw string with \N{...} - both {angle} are format placeholders, should convert.
+    - r"\N{angle}AOB = {angle}°".format(angle=180)
+283 + rf"\N{180}AOB = {180}°"

crates/ruff_python_literal/src/format.rs

@@ -589,12 +589,14 @@ impl FormatString {
         Ok((first_char, chars.as_str()))
     }
 
-    fn parse_literal(text: &str) -> Result<(FormatPart, &str), FormatParseError> {
+    fn parse_literal(text: &str, is_raw: bool) -> Result<(FormatPart, &str), FormatParseError> {
         let mut cur_text = text;
         let mut result_string = String::new();
         let mut pending_escape = false;
         while !cur_text.is_empty() {
-            if pending_escape
+            // Raw strings: \N{...} is literal, not a Unicode escape
+            if !is_raw
+                && pending_escape
                 && let Some((unicode_string, remaining)) =
                     FormatString::parse_escaped_unicode_string(cur_text)
             {
@@ -697,23 +699,12 @@ impl FormatString {
             (&text[..end_idx], &text[end_idx..])
         })
     }
-}
-
-pub trait FromTemplate<'a>: Sized {
-    type Err;
-    fn from_str(s: &'a str) -> Result<Self, Self::Err>;
-}
 
-impl<'a> FromTemplate<'a> for FormatString {
-    type Err = FormatParseError;
-
-    fn from_str(text: &'a str) -> Result<Self, Self::Err> {
+    pub fn parse(text: &str, is_raw: bool) -> Result<Self, FormatParseError> {
         let mut cur_text: &str = text;
         let mut parts: Vec<FormatPart> = Vec::new();
         while !cur_text.is_empty() {
-            // Try to parse both literals and bracketed format parts until we
-            // run out of text
-            cur_text = FormatString::parse_literal(cur_text)
+            cur_text = FormatString::parse_literal(cur_text, is_raw)
                 .or_else(|_| FormatString::parse_spec(cur_text, AllowPlaceholderNesting::Yes))
                 .map(|(part, new_text)| {
                     parts.push(part);
@@ -726,6 +717,19 @@ impl<'a> FromTemplate<'a> for FormatString {
     }
 }
 
+pub trait FromTemplate<'a>: Sized {
+    type Err;
+    fn from_str(s: &'a str) -> Result<Self, Self::Err>;
+}
+
+impl<'a> FromTemplate<'a> for FormatString {
+    type Err = FormatParseError;
+
+    fn from_str(text: &'a str) -> Result<Self, Self::Err> {
+        FormatString::parse(text, false)
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;