Simplify formatting of strings by using flags from the AST nodes (#10489)

crates/ruff_python_formatter/src/other/bytes_literal.rs

@@ -1,8 +1,7 @@
 use ruff_python_ast::BytesLiteral;
-use ruff_text_size::Ranged;
 
 use crate::prelude::*;
-use crate::string::{StringNormalizer, StringPart};
+use crate::string::StringNormalizer;
 
 #[derive(Default)]
 pub struct FormatBytesLiteral;
@@ -13,7 +12,7 @@ impl FormatNodeRule<BytesLiteral> for FormatBytesLiteral {
 
         StringNormalizer::from_context(f.context())
             .with_preferred_quote_style(f.options().quote_style())
-            .normalize(&StringPart::from_source(item.range(), &locator), &locator)
+            .normalize(item.into(), &locator)
             .fmt(f)
     }
 }

crates/ruff_python_formatter/src/other/f_string.rs

@@ -1,11 +1,10 @@
 use ruff_formatter::write;
-use ruff_python_ast::FString;
+use ruff_python_ast::{AnyStringKind, FString};
 use ruff_source_file::Locator;
-use ruff_text_size::Ranged;
 
 use crate::prelude::*;
 use crate::preview::is_f_string_formatting_enabled;
-use crate::string::{Quoting, StringNormalizer, StringPart, StringPrefix, StringQuotes};
+use crate::string::{Quoting, StringNormalizer, StringQuotes};
 
 use super::f_string_element::FormatFStringElement;
 
@@ -30,8 +29,6 @@ impl Format<PyFormatContext<'_>> for FormatFString<'_> {
     fn fmt(&self, f: &mut PyFormatter) -> FormatResult<()> {
         let locator = f.context().locator();
 
-        let string = StringPart::from_source(self.value.range(), &locator);
-
         let normalizer = StringNormalizer::from_context(f.context())
             .with_quoting(self.quoting)
             .with_preferred_quote_style(f.options().quote_style());
@@ -39,7 +36,7 @@ impl Format<PyFormatContext<'_>> for FormatFString<'_> {
         // If f-string formatting is disabled (not in preview), then we will
         // fall back to the previous behavior of normalizing the f-string.
         if !is_f_string_formatting_enabled(f.context()) {
-            let result = normalizer.normalize(&string, &locator).fmt(f);
+            let result = normalizer.normalize(self.value.into(), &locator).fmt(f);
             let comments = f.context().comments();
             self.value.elements.iter().for_each(|value| {
                 comments.mark_verbatim_node_comments_formatted(value.into());
@@ -59,16 +56,16 @@ impl Format<PyFormatContext<'_>> for FormatFString<'_> {
             return result;
         }
 
-        let quote_selection = normalizer.choose_quotes(&string, &locator);
+        let string_kind = normalizer.choose_quotes(self.value.into(), &locator).kind();
 
         let context = FStringContext::new(
-            string.prefix(),
-            quote_selection.quotes(),
+            string_kind,
             FStringLayout::from_f_string(self.value, &locator),
         );
 
         // Starting prefix and quote
-        write!(f, [string.prefix(), quote_selection.quotes()])?;
+        let quotes = StringQuotes::from(string_kind);
+        write!(f, [string_kind.prefix(), quotes])?;
 
         f.join()
             .entries(
@@ -80,32 +77,23 @@ impl Format<PyFormatContext<'_>> for FormatFString<'_> {
             .finish()?;
 
         // Ending quote
-        quote_selection.quotes().fmt(f)
+        quotes.fmt(f)
     }
 }
 
 #[derive(Clone, Copy, Debug)]
 pub(crate) struct FStringContext {
-    prefix: StringPrefix,
-    quotes: StringQuotes,
+    kind: AnyStringKind,
     layout: FStringLayout,
 }
 
 impl FStringContext {
-    const fn new(prefix: StringPrefix, quotes: StringQuotes, layout: FStringLayout) -> Self {
-        Self {
-            prefix,
-            quotes,
-            layout,
-        }
+    const fn new(kind: AnyStringKind, layout: FStringLayout) -> Self {
+        Self { kind, layout }
     }
 
-    pub(crate) const fn quotes(self) -> StringQuotes {
-        self.quotes
-    }
-
-    pub(crate) const fn prefix(self) -> StringPrefix {
-        self.prefix
+    pub(crate) fn kind(self) -> AnyStringKind {
+        self.kind
     }
 
     pub(crate) const fn layout(self) -> FStringLayout {

crates/ruff_python_formatter/src/other/f_string_element.rs

@@ -56,13 +56,7 @@ impl<'a> FormatFStringLiteralElement<'a> {
 impl Format<PyFormatContext<'_>> for FormatFStringLiteralElement<'_> {
     fn fmt(&self, f: &mut PyFormatter) -> FormatResult<()> {
         let literal_content = f.context().locator().slice(self.element.range());
-        let normalized = normalize_string(
-            literal_content,
-            0,
-            self.context.quotes(),
-            self.context.prefix(),
-            true,
-        );
+        let normalized = normalize_string(literal_content, 0, self.context.kind(), true);
         match &normalized {
             Cow::Borrowed(_) => source_text_slice(self.element.range()).fmt(f),
             Cow::Owned(normalized) => text(normalized).fmt(f),

crates/ruff_python_formatter/src/other/string_literal.rs

@@ -1,8 +1,7 @@
 use ruff_python_ast::StringLiteral;
-use ruff_text_size::Ranged;
 
 use crate::prelude::*;
-use crate::string::{docstring, Quoting, StringNormalizer, StringPart};
+use crate::string::{docstring, Quoting, StringNormalizer};
 use crate::QuoteStyle;
 
 pub(crate) struct FormatStringLiteral<'a> {
@@ -61,10 +60,7 @@ impl Format<PyFormatContext<'_>> for FormatStringLiteral<'_> {
         let normalized = StringNormalizer::from_context(f.context())
             .with_quoting(self.layout.quoting())
             .with_preferred_quote_style(quote_style)
-            .normalize(
-                &StringPart::from_source(self.value.range(), &locator),
-                &locator,
-            );
+            .normalize(self.value.into(), &locator);
 
         if self.layout.is_docstring() {
             docstring::format(&normalized, f)