Unify enums used for internal representation of quoting style (#10383)

crates/ruff_python_codegen/src/generator.rs

@@ -2,6 +2,7 @@
 
 use std::ops::Deref;
 
+use ruff_python_ast::str::Quote;
 use ruff_python_ast::{
     self as ast, Alias, ArgOrKeyword, BoolOp, CmpOp, Comprehension, ConversionFlag, DebugText,
     ExceptHandler, Expr, Identifier, MatchCase, Operator, Parameter, Parameters, Pattern,
@@ -12,7 +13,7 @@ use ruff_python_ast::{ParameterWithDefault, TypeParams};
 use ruff_python_literal::escape::{AsciiEscape, Escape, UnicodeEscape};
 use ruff_source_file::LineEnding;
 
-use super::stylist::{Indentation, Quote, Stylist};
+use super::stylist::{Indentation, Stylist};
 
 mod precedence {
     pub(crate) const NAMED_EXPR: u8 = 1;
@@ -150,7 +151,7 @@ impl<'a> Generator<'a> {
     }
 
     fn p_bytes_repr(&mut self, s: &[u8]) {
-        let escape = AsciiEscape::with_preferred_quote(s, self.quote.into());
+        let escape = AsciiEscape::with_preferred_quote(s, self.quote);
         if let Some(len) = escape.layout().len {
             self.buffer.reserve(len);
         }
@@ -158,7 +159,7 @@ impl<'a> Generator<'a> {
     }
 
     fn p_str_repr(&mut self, s: &str) {
-        let escape = UnicodeEscape::with_preferred_quote(s, self.quote.into());
+        let escape = UnicodeEscape::with_preferred_quote(s, self.quote);
         if let Some(len) = escape.layout().len {
             self.buffer.reserve(len);
         }
@@ -1373,14 +1374,8 @@ impl<'a> Generator<'a> {
             self.unparse_f_string_body(values);
         } else {
             self.p("f");
-            let mut generator = Generator::new(
-                self.indent,
-                match self.quote {
-                    Quote::Single => Quote::Double,
-                    Quote::Double => Quote::Single,
-                },
-                self.line_ending,
-            );
+            let mut generator =
+                Generator::new(self.indent, self.quote.opposite(), self.line_ending);
             generator.unparse_f_string_body(values);
             let body = &generator.buffer;
             self.p_str_repr(body);
@@ -1406,11 +1401,11 @@ impl<'a> Generator<'a> {
 
 #[cfg(test)]
 mod tests {
-    use ruff_python_ast::{Mod, ModModule};
+    use ruff_python_ast::{str::Quote, Mod, ModModule};
     use ruff_python_parser::{self, parse_suite, Mode};
     use ruff_source_file::LineEnding;
 
-    use crate::stylist::{Indentation, Quote};
+    use crate::stylist::Indentation;
 
     use super::Generator;
 

crates/ruff_python_codegen/src/lib.rs

@@ -4,7 +4,7 @@ mod stylist;
 pub use generator::Generator;
 use ruff_python_parser::{lexer, parse_suite, Mode, ParseError};
 use ruff_source_file::Locator;
-pub use stylist::{Quote, Stylist};
+pub use stylist::Stylist;
 
 /// Run round-trip source code generation on a given Python code.
 pub fn round_trip(code: &str) -> Result<String, ParseError> {

crates/ruff_python_codegen/src/stylist.rs

@@ -1,15 +1,13 @@
 //! Detect code style from Python source code.
 
-use std::fmt;
 use std::ops::Deref;
 
 use once_cell::unsync::OnceCell;
-use ruff_python_literal::escape::Quote as StrQuote;
+
+use ruff_python_ast::str::Quote;
 use ruff_python_parser::lexer::LexResult;
 use ruff_python_parser::Tok;
-use ruff_source_file::{find_newline, LineEnding};
-
-use ruff_source_file::Locator;
+use ruff_source_file::{find_newline, LineEnding, Locator};
 
 #[derive(Debug, Clone)]
 pub struct Stylist<'a> {
@@ -52,10 +50,8 @@ impl<'a> Stylist<'a> {
 fn detect_quote(tokens: &[LexResult]) -> Quote {
     for (token, _) in tokens.iter().flatten() {
         match token {
-            Tok::String { kind, .. } if !kind.is_triple_quoted() => {
-                return kind.quote_style().into()
-            }
-            Tok::FStringStart(kind) => return kind.quote_style().into(),
+            Tok::String { kind, .. } if !kind.is_triple_quoted() => return kind.quote_style(),
+            Tok::FStringStart(kind) => return kind.quote_style(),
             _ => continue,
         }
     }
@@ -94,50 +90,6 @@ fn detect_indention(tokens: &[LexResult], locator: &Locator) -> Indentation {
     }
 }
 
-/// The quotation style used in Python source code.
-#[derive(Debug, Default, PartialEq, Eq, Copy, Clone)]
-pub enum Quote {
-    Single,
-    #[default]
-    Double,
-}
-
-impl From<ruff_python_ast::str::QuoteStyle> for Quote {
-    fn from(value: ruff_python_ast::str::QuoteStyle) -> Self {
-        match value {
-            ruff_python_ast::str::QuoteStyle::Double => Self::Double,
-            ruff_python_ast::str::QuoteStyle::Single => Self::Single,
-        }
-    }
-}
-
-impl From<Quote> for char {
-    fn from(val: Quote) -> Self {
-        match val {
-            Quote::Single => '\'',
-            Quote::Double => '"',
-        }
-    }
-}
-
-impl From<Quote> for StrQuote {
-    fn from(val: Quote) -> Self {
-        match val {
-            Quote::Single => StrQuote::Single,
-            Quote::Double => StrQuote::Double,
-        }
-    }
-}
-
-impl fmt::Display for Quote {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            Quote::Single => write!(f, "\'"),
-            Quote::Double => write!(f, "\""),
-        }
-    }
-}
-
 /// The indentation style used in Python source code.
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct Indentation(String);