Pass StringKind around rather than StringQuotes in the formatter

Author: AlexWaygood

Cargo.lock

@@ -25,7 +25,6 @@ ruff_python_parser = { path = "../ruff_python_parser" }
 ruff_text_size = { path = "../ruff_text_size" }
 
 anyhow = { workspace = true }
-bitflags = { workspace = true }
 clap = { workspace = true }
 countme = { workspace = true }
 itertools = { workspace = true }

crates/ruff_python_formatter/Cargo.toml

@@ -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, &locator)
             .fmt(f)
     }
 }

crates/ruff_python_formatter/src/other/bytes_literal.rs

@@ -1,11 +1,11 @@
 use ruff_formatter::write;
 use ruff_python_ast::FString;
+use ruff_python_parser::StringKind;
 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,16 +30,14 @@ 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());
 
         // 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, &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 +57,16 @@ impl Format<PyFormatContext<'_>> for FormatFString<'_> {
             return result;
         }
 
-        let quote_selection = normalizer.choose_quotes(&string, &locator);
+        let string_kind = normalizer.choose_quotes(self.value, &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 +78,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: StringKind,
     layout: FStringLayout,
 }
 
 impl FStringContext {
-    const fn new(prefix: StringPrefix, quotes: StringQuotes, layout: FStringLayout) -> Self {
-        Self {
-            prefix,
-            quotes,
-            layout,
-        }
-    }
-
-    pub(crate) const fn quotes(self) -> StringQuotes {
-        self.quotes
+    const fn new(kind: StringKind, layout: FStringLayout) -> Self {
+        Self { kind, layout }
     }
 
-    pub(crate) const fn prefix(self) -> StringPrefix {
-        self.prefix
+    pub(crate) fn kind(self) -> StringKind {
+        self.kind
     }
 
     pub(crate) const fn layout(self) -> FStringLayout {

crates/ruff_python_formatter/src/other/f_string.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/f_string_element.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, &locator);
 
         if self.layout.is_docstring() {
             docstring::format(&normalized, f)

crates/ruff_python_formatter/src/other/string_literal.rs

@@ -18,6 +18,7 @@ use {
     ruff_text_size::{Ranged, TextLen, TextRange, TextSize},
 };
 
+use crate::string::StringQuotes;
 use crate::{prelude::*, DocstringCodeLineWidth, FormatModuleError};
 
 use super::NormalizedString;
@@ -126,7 +127,9 @@ pub(crate) fn format(normalized: &NormalizedString, f: &mut PyFormatter) -> Form
     let mut lines = docstring.split('\n').peekable();
 
     // Start the string
-    write!(f, [normalized.prefix(), normalized.quotes()])?;
+    let kind = normalized.kind();
+    let quotes = StringQuotes::from(kind);
+    write!(f, [kind.prefix(), quotes])?;
     // We track where in the source docstring we are (in source code byte offsets)
     let mut offset = normalized.start();
 
@@ -142,7 +145,7 @@ pub(crate) fn format(normalized: &NormalizedString, f: &mut PyFormatter) -> Form
 
     // Edge case: The first line is `""" "content`, so we need to insert chaperone space that keep
     // inner quotes and closing quotes from getting to close to avoid `""""content`
-    if trim_both.starts_with(normalized.quotes().quote_char.as_char()) {
+    if trim_both.starts_with(quotes.quote_char.as_char()) {
         space().fmt(f)?;
     }
 
@@ -169,7 +172,7 @@ pub(crate) fn format(normalized: &NormalizedString, f: &mut PyFormatter) -> Form
         {
             space().fmt(f)?;
         }
-        normalized.quotes().fmt(f)?;
+        quotes.fmt(f)?;
         return Ok(());
     }
 
@@ -195,7 +198,7 @@ pub(crate) fn format(normalized: &NormalizedString, f: &mut PyFormatter) -> Form
         offset,
         stripped_indentation,
         already_normalized,
-        quote_char: normalized.quotes().quote_char,
+        quote_char: quotes.quote_char,
         code_example: CodeExample::default(),
     }
     .add_iter(lines)?;
@@ -208,7 +211,7 @@ pub(crate) fn format(normalized: &NormalizedString, f: &mut PyFormatter) -> Form
         space().fmt(f)?;
     }
 
-    write!(f, [normalized.quotes()])
+    write!(f, [quotes])
 }
 
 fn contains_unescaped_newline(haystack: &str) -> bool {
@@ -1570,7 +1573,7 @@ fn docstring_format_source(
 /// that avoids `content""""` and `content\"""`. This does only applies to un-escaped backslashes,
 /// so `content\\ """` doesn't need a space while `content\\\ """` does.
 fn needs_chaperone_space(normalized: &NormalizedString, trim_end: &str) -> bool {
-    trim_end.ends_with(normalized.quotes().quote_char.as_char())
+    trim_end.ends_with(normalized.kind().quote_style().as_char())
         || trim_end.chars().rev().take_while(|c| *c == '\\').count() % 2 == 1
 }