Start tracking quoting style in the AST (#10298)

This PR modifies our AST so that nodes for string literals, bytes literals and f-strings all retain the following information:
- The quoting style used (double or single quotes)
- Whether the string is triple-quoted or not
- Whether the string is raw or not

This PR is a followup to #10256. Like with that PR, this PR does not, in itself, fix any bugs. However, it means that we will have the necessary information to preserve quoting style and rawness of strings in the `ExprGenerator` in a followup PR, which will allow us to provide a fix for https://github.com/astral-sh/ruff/issues/7799.

The information is recorded on the AST nodes using a bitflag field on each node, similarly to how we recorded the information on `Tok::String`, `Tok::FStringStart` and `Tok::FStringMiddle` tokens in #10298. Rather than reusing the bitflag I used for the tokens, however, I decided to create a custom bitflag for each AST node.

Using different bitflags for each node allows us to make invalid states unrepresentable: it is valid to set a `u` prefix on a string literal, but not on a bytes literal or an f-string. It also allows us to have better debug representations for each AST node modified in this PR.

crates/ruff_linter/src/rules/flake8_quotes/settings.rs

@@ -22,11 +22,11 @@ impl Default for Quote {
     }
 }
 
-impl From<ruff_python_parser::QuoteStyle> for Quote {
+impl From<ruff_python_ast::str::QuoteStyle> for Quote {
-    fn from(value: ruff_python_parser::QuoteStyle) -> Self {
+    fn from(value: ruff_python_ast::str::QuoteStyle) -> Self {
         match value {
-            ruff_python_parser::QuoteStyle::Double => Self::Double,
+            ruff_python_ast::str::QuoteStyle::Double => Self::Double,
-            ruff_python_parser::QuoteStyle::Single => Self::Single,
+            ruff_python_ast::str::QuoteStyle::Single => Self::Single,
         }
     }
 }

crates/ruff_linter/src/rules/flake8_simplify/rules/ast_expr.rs

@@ -1,3 +1,4 @@
+use ast::{StringLiteralFlags, StringLiteralPrefix};
 use ruff_python_ast::{self as ast, Arguments, Expr};
 use ruff_text_size::Ranged;
 
@@ -218,7 +219,13 @@ fn check_os_environ_subscript(checker: &mut Checker, expr: &Expr) {
     );
     let node = ast::StringLiteral {
         value: capital_env_var.into_boxed_str(),
-        unicode: env_var.is_unicode(),
+        flags: StringLiteralFlags::default().with_prefix({
+            if env_var.is_unicode() {
+                StringLiteralPrefix::UString
+            } else {
+                StringLiteralPrefix::None
+            }
+        }),
         ..ast::StringLiteral::default()
     };
     let new_env_var = node.into();

crates/ruff_linter/src/rules/flynt/rules/static_join_to_fstring.rs

@@ -1,3 +1,4 @@
+use ast::FStringFlags;
 use itertools::Itertools;
 
 use crate::fix::edits::pad;
@@ -97,6 +98,7 @@ fn build_fstring(joiner: &str, joinees: &[Expr]) -> Option<Expr> {
     let node = ast::FString {
         elements: f_string_elements,
         range: TextRange::default(),
+        flags: FStringFlags::default(),
     };
     Some(node.into())
 }

crates/ruff_linter/src/rules/pylint/rules/unspecified_encoding.rs

@@ -1,5 +1,6 @@
 use anyhow::Result;
 
+use ast::StringLiteralFlags;
 use ruff_diagnostics::{AlwaysFixableViolation, Diagnostic, Fix};
 use ruff_macros::{derive_message_formats, violation};
 use ruff_python_ast as ast;
@@ -106,7 +107,7 @@ fn generate_keyword_fix(checker: &Checker, call: &ast::ExprCall) -> Fix {
                 .expr(&Expr::StringLiteral(ast::ExprStringLiteral {
                     value: ast::StringLiteralValue::single(ast::StringLiteral {
                         value: "locale".to_string().into_boxed_str(),
-                        unicode: false,
+                        flags: StringLiteralFlags::default(),
                         range: TextRange::default(),
                     }),
                     range: TextRange::default(),

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

@@ -40,7 +40,7 @@ impl AlwaysFixableViolation for UnicodeKindPrefix {
 
 /// UP025
 pub(crate) fn unicode_kind_prefix(checker: &mut Checker, string: &StringLiteral) {
-    if string.unicode {
+    if string.flags.is_u_string() {
         let mut diagnostic = Diagnostic::new(UnicodeKindPrefix, string.range);
         diagnostic.set_fix(Fix::safe_edit(Edit::range_deletion(TextRange::at(
             string.start(),

crates/ruff_python_ast/src/node.rs

@@ -4430,7 +4430,11 @@ impl AstNode for ast::FString {
     where
         V: PreorderVisitor<'a> + ?Sized,
     {
-        let ast::FString { elements, range: _ } = self;
+        let ast::FString {
+            elements,
+            range: _,
+            flags: _,
+        } = self;
 
         for fstring_element in elements {
             visitor.visit_f_string_element(fstring_element);

crates/ruff_python_ast/src/nodes.rs

@@ -6,11 +6,12 @@ use std::fmt::Debug;
 use std::ops::Deref;
 use std::slice::{Iter, IterMut};
 
+use bitflags::bitflags;
 use itertools::Itertools;
 
 use ruff_text_size::{Ranged, TextRange, TextSize};
 
-use crate::{int, LiteralExpressionRef};
+use crate::{int, str::QuoteStyle, LiteralExpressionRef};
 
 /// See also [mod](https://docs.python.org/3/library/ast.html#ast.mod)
 #[derive(Clone, Debug, PartialEq, is_macro::Is)]
@@ -1167,11 +1168,84 @@ impl Ranged for FStringPart {
     }
 }
 
+bitflags! {
+    #[derive(Default, Copy, Clone, PartialEq, Eq, Hash)]
+    struct FStringFlagsInner: u8 {
+        /// The f-string uses double quotes (`"`) for its opener and closer.
+        /// If this flag is not set, the f-string uses single quotes (`'`)
+        /// for its opener and closer.
+        const DOUBLE = 1 << 0;
+
+        /// The f-string is triple-quoted:
+        /// it begins and ends with three consecutive quote characters.
+        const TRIPLE_QUOTED = 1 << 1;
+
+        /// The f-string has an `r` or `R` prefix, meaning it is a raw f-string.
+        const R_PREFIX = 1 << 3;
+    }
+}
+
+/// Flags that can be queried to obtain information
+/// regarding the prefixes and quotes used for an f-string.
+#[derive(Default, Copy, Clone, Eq, PartialEq, Hash)]
+pub struct FStringFlags(FStringFlagsInner);
+
+impl FStringFlags {
+    #[must_use]
+    pub fn with_double_quotes(mut self) -> Self {
+        self.0 |= FStringFlagsInner::DOUBLE;
+        self
+    }
+
+    #[must_use]
+    pub fn with_triple_quotes(mut self) -> Self {
+        self.0 |= FStringFlagsInner::TRIPLE_QUOTED;
+        self
+    }
+
+    #[must_use]
+    pub fn with_r_prefix(mut self) -> Self {
+        self.0 |= FStringFlagsInner::R_PREFIX;
+        self
+    }
+
+    /// Does the f-string have an `r` or `R` prefix?
+    pub const fn is_raw(self) -> bool {
+        self.0.contains(FStringFlagsInner::R_PREFIX)
+    }
+
+    /// Is the f-string triple-quoted, i.e.,
+    /// does it begin and end with three consecutive quote characters?
+    pub const fn is_triple_quoted(self) -> bool {
+        self.0.contains(FStringFlagsInner::TRIPLE_QUOTED)
+    }
+
+    /// Does the f-string use single or double quotes in its opener and closer?
+    pub const fn quote_style(self) -> QuoteStyle {
+        if self.0.contains(FStringFlagsInner::DOUBLE) {
+            QuoteStyle::Double
+        } else {
+            QuoteStyle::Single
+        }
+    }
+}
+
+impl fmt::Debug for FStringFlags {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("FStringFlags")
+            .field("quote_style", &self.quote_style())
+            .field("raw", &self.is_raw())
+            .field("triple_quoted", &self.is_triple_quoted())
+            .finish()
+    }
+}
+
 /// An AST node that represents a single f-string which is part of an [`ExprFString`].
 #[derive(Clone, Debug, PartialEq)]
 pub struct FString {
     pub range: TextRange,
     pub elements: Vec<FStringElement>,
+    pub flags: FStringFlags,
 }
 
 impl Ranged for FString {
@@ -1266,7 +1340,9 @@ impl StringLiteralValue {
     /// For an implicitly concatenated string, it returns `true` only if the first
     /// string literal is a unicode string.
     pub fn is_unicode(&self) -> bool {
-        self.iter().next().map_or(false, |part| part.unicode)
+        self.iter()
+            .next()
+            .map_or(false, |part| part.flags.is_u_string())
     }
 
     /// Returns a slice of all the [`StringLiteral`] parts contained in this value.
@@ -1379,13 +1455,131 @@ impl Default for StringLiteralValueInner {
     }
 }
 
+bitflags! {
+    #[derive(Debug, Default, Copy, Clone, PartialEq, Eq, Hash)]
+    struct StringLiteralFlagsInner: u8 {
+        /// The string uses double quotes (`"`).
+        /// If this flag is not set, the string uses single quotes (`'`).
+        const DOUBLE = 1 << 0;
+
+        /// The string is triple-quoted:
+        /// it begins and ends with three consecutive quote characters.
+        const TRIPLE_QUOTED = 1 << 1;
+
+        /// The string has a `u` or `U` prefix.
+        /// While this prefix is a no-op at runtime,
+        /// strings with this prefix can have no other prefixes set;
+        /// it is therefore invalid for this flag to be set
+        /// if `R_PREFIX` is also set.
+        const U_PREFIX = 1 << 2;
+
+        /// The string has an `r` or `R` prefix, meaning it is a raw string.
+        /// It is invalid to set this flag if `U_PREFIX` is also set.
+        const R_PREFIX = 1 << 3;
+    }
+}
+
+/// Flags that can be queried to obtain information
+/// regarding the prefixes and quotes used for a string literal.
+#[derive(Default, Copy, Clone, Eq, PartialEq, Hash)]
+pub struct StringLiteralFlags(StringLiteralFlagsInner);
+
+impl StringLiteralFlags {
+    #[must_use]
+    pub fn with_double_quotes(mut self) -> Self {
+        self.0 |= StringLiteralFlagsInner::DOUBLE;
+        self
+    }
+
+    #[must_use]
+    pub fn with_triple_quotes(mut self) -> Self {
+        self.0 |= StringLiteralFlagsInner::TRIPLE_QUOTED;
+        self
+    }
+
+    #[must_use]
+    pub fn with_prefix(mut self, prefix: StringLiteralPrefix) -> Self {
+        match prefix {
+            StringLiteralPrefix::None => {}
+            StringLiteralPrefix::RString => self.0 |= StringLiteralFlagsInner::R_PREFIX,
+            StringLiteralPrefix::UString => self.0 |= StringLiteralFlagsInner::U_PREFIX,
+        };
+        self
+    }
+
+    pub const fn prefix(self) -> &'static str {
+        if self.0.contains(StringLiteralFlagsInner::U_PREFIX) {
+            debug_assert!(!self.0.contains(StringLiteralFlagsInner::R_PREFIX));
+            "u"
+        } else if self.0.contains(StringLiteralFlagsInner::R_PREFIX) {
+            "r"
+        } else {
+            ""
+        }
+    }
+
+    /// Does the string use single or double quotes in its opener and closer?
+    pub const fn quote_style(self) -> QuoteStyle {
+        if self.0.contains(StringLiteralFlagsInner::DOUBLE) {
+            QuoteStyle::Double
+        } else {
+            QuoteStyle::Single
+        }
+    }
+
+    /// Is the string triple-quoted, i.e.,
+    /// does it begin and end with three consecutive quote characters?
+    pub const fn is_triple_quoted(self) -> bool {
+        self.0.contains(StringLiteralFlagsInner::TRIPLE_QUOTED)
+    }
+
+    /// Does the string have a `u` or `U` prefix?
+    pub const fn is_u_string(&self) -> bool {
+        self.0.contains(StringLiteralFlagsInner::U_PREFIX)
+    }
+
+    /// Does the string have an `r` or `R` prefix?
+    pub const fn is_r_string(&self) -> bool {
+        self.0.contains(StringLiteralFlagsInner::R_PREFIX)
+    }
+}
+
+impl fmt::Debug for StringLiteralFlags {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("StringLiteralFlags")
+            .field("quote_style", &self.quote_style())
+            .field("prefix", &self.prefix())
+            .field("triple_quoted", &self.is_triple_quoted())
+            .finish()
+    }
+}
+
+/// Enumerations of the valid prefixes a string literal can have.
+///
+/// Bytestrings and f-strings are excluded from this enumeration,
+/// as they are represented by different AST nodes.
+#[derive(Debug, Default, Copy, Clone, PartialEq, Eq, Hash)]
+pub enum StringLiteralPrefix {
+    /// Just a regular string with no prefixes
+    #[default]
+    None,
+
+    /// A string with a `u` or `U` prefix.
+    /// This is a no-op at runtime,
+    /// but is mutually exclusive with a string having an `r` prefix.
+    UString,
+
+    /// A "raw" string, that has an `r` or `R` prefix
+    RString,
+}
+
 /// An AST node that represents a single string literal which is part of an
 /// [`ExprStringLiteral`].
 #[derive(Clone, Debug, Default, PartialEq)]
 pub struct StringLiteral {
     pub range: TextRange,
     pub value: Box<str>,
-    pub unicode: bool,
+    pub flags: StringLiteralFlags,
 }
 
 impl Ranged for StringLiteral {
@@ -1602,12 +1796,84 @@ impl Default for BytesLiteralValueInner {
     }
 }
 
+bitflags! {
+    #[derive(Default, Copy, Clone, PartialEq, Eq, Hash)]
+    struct BytesLiteralFlagsInner: u8 {
+        /// The bytestring uses double quotes (`"`).
+        /// If this flag is not set, the bytestring uses single quotes (`'`).
+        const DOUBLE = 1 << 0;
+
+        /// The bytestring is triple-quoted:
+        /// it begins and ends with three consecutive quote characters.
+        const TRIPLE_QUOTED = 1 << 1;
+
+        /// The bytestring has an `r` or `R` prefix, meaning it is a raw bytestring.
+        const R_PREFIX = 1 << 3;
+    }
+}
+
+/// Flags that can be queried to obtain information
+/// regarding the prefixes and quotes used for a bytes literal.
+#[derive(Default, Copy, Clone, Eq, PartialEq, Hash)]
+pub struct BytesLiteralFlags(BytesLiteralFlagsInner);
+
+impl BytesLiteralFlags {
+    #[must_use]
+    pub fn with_double_quotes(mut self) -> Self {
+        self.0 |= BytesLiteralFlagsInner::DOUBLE;
+        self
+    }
+
+    #[must_use]
+    pub fn with_triple_quotes(mut self) -> Self {
+        self.0 |= BytesLiteralFlagsInner::TRIPLE_QUOTED;
+        self
+    }
+
+    #[must_use]
+    pub fn with_r_prefix(mut self) -> Self {
+        self.0 |= BytesLiteralFlagsInner::R_PREFIX;
+        self
+    }
+
+    /// Does the bytestring have an `r` or `R` prefix?
+    pub const fn is_raw(self) -> bool {
+        self.0.contains(BytesLiteralFlagsInner::R_PREFIX)
+    }
+
+    /// Is the bytestring triple-quoted, i.e.,
+    /// does it begin and end with three consecutive quote characters?
+    pub const fn is_triple_quoted(self) -> bool {
+        self.0.contains(BytesLiteralFlagsInner::TRIPLE_QUOTED)
+    }
+
+    /// Does the bytestring use single or double quotes in its opener and closer?
+    pub const fn quote_style(self) -> QuoteStyle {
+        if self.0.contains(BytesLiteralFlagsInner::DOUBLE) {
+            QuoteStyle::Double
+        } else {
+            QuoteStyle::Single
+        }
+    }
+}
+
+impl fmt::Debug for BytesLiteralFlags {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("BytesLiteralFlags")
+            .field("quote_style", &self.quote_style())
+            .field("raw", &self.is_raw())
+            .field("triple_quoted", &self.is_triple_quoted())
+            .finish()
+    }
+}
+
 /// An AST node that represents a single bytes literal which is part of an
 /// [`ExprBytesLiteral`].
 #[derive(Clone, Debug, Default, PartialEq)]
 pub struct BytesLiteral {
     pub range: TextRange,
     pub value: Box<[u8]>,
+    pub flags: BytesLiteralFlags,
 }
 
 impl Ranged for BytesLiteral {

crates/ruff_python_ast/src/str.rs

@@ -3,6 +3,32 @@ use once_cell::sync::Lazy;
 
 use ruff_text_size::{TextLen, TextRange};
 
+#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq, is_macro::Is)]
+pub enum QuoteStyle {
+    /// E.g. '
+    Single,
+    /// E.g. "
+    #[default]
+    Double,
+}
+
+impl QuoteStyle {
+    pub const fn as_char(self) -> char {
+        match self {
+            Self::Single => '\'',
+            Self::Double => '"',
+        }
+    }
+
+    #[must_use]
+    pub const fn opposite(self) -> Self {
+        match self {
+            Self::Single => Self::Double,
+            Self::Double => Self::Single,
+        }
+    }
+}
+
 /// Includes all permutations of `r`, `u`, `f`, and `fr` (`ur` is invalid, as is `uf`). This
 /// includes all possible orders, and all possible casings, for both single and triple quotes.
 ///

crates/ruff_python_codegen/src/generator.rs

@@ -1267,7 +1267,7 @@ impl<'a> Generator<'a> {
     }
 
     fn unparse_string_literal(&mut self, string_literal: &ast::StringLiteral) {
-        if string_literal.unicode {
+        if string_literal.flags.is_u_string() {
             self.p("u");
         }
         self.p_str_repr(&string_literal.value);

crates/ruff_python_codegen/src/stylist.rs

@@ -102,11 +102,11 @@ pub enum Quote {
     Double,
 }
 
-impl From<ruff_python_parser::QuoteStyle> for Quote {
+impl From<ruff_python_ast::str::QuoteStyle> for Quote {
-    fn from(value: ruff_python_parser::QuoteStyle) -> Self {
+    fn from(value: ruff_python_ast::str::QuoteStyle) -> Self {
         match value {
-            ruff_python_parser::QuoteStyle::Double => Self::Double,
+            ruff_python_ast::str::QuoteStyle::Double => Self::Double,
-            ruff_python_parser::QuoteStyle::Single => Self::Single,
+            ruff_python_ast::str::QuoteStyle::Single => Self::Single,
         }
     }
 }

crates/ruff_python_parser/src/lib.rs

@@ -115,7 +115,7 @@ pub use parser::{
 };
 use ruff_python_ast::{Mod, PySourceType, Suite};
 pub use string::FStringErrorType;
-pub use string_token_flags::{QuoteStyle, StringKind};
+pub use string_token_flags::StringKind;
 pub use token::{Tok, TokenKind};
 
 use crate::lexer::LexResult;

crates/ruff_python_parser/src/python.lalrpop

@@ -1626,10 +1626,11 @@ StringLiteral: StringType = {
 };
 
 FStringExpr: StringType = {
-    <location:@L> FStringStart <elements:FStringMiddlePattern*> FStringEnd <end_location:@R> => {
+    <location:@L> <start:fstring_start> <elements:FStringMiddlePattern*> FStringEnd <end_location:@R> => {
         StringType::FString(ast::FString {
             elements,
-            range: (location..end_location).into()
+            range: (location..end_location).into(),
+            flags: start.into()
         })
     }
 };
@@ -2002,7 +2003,7 @@ extern {
         Dedent => token::Tok::Dedent,
         StartModule => token::Tok::StartModule,
         StartExpression => token::Tok::StartExpression,
-        FStringStart => token::Tok::FStringStart(StringKind),
+        fstring_start => token::Tok::FStringStart(<StringKind>),
         FStringEnd => token::Tok::FStringEnd,
         "!" => token::Tok::Exclamation,
         "?" => token::Tok::Question,

crates/ruff_python_parser/src/snapshots/ruff_python_parser__invalid__tests__ok_attribute_weird.snap

@@ -19,7 +19,11 @@ Ok(
                                             StringLiteral {
                                                 range: 0..5,
                                                 value: "foo",
-                                                unicode: false,
+                                                flags: StringLiteralFlags {
+                                                    quote_style: Double,
+                                                    prefix: "",
+                                                    triple_quoted: false,
+                                                },
                                             },
                                         ),
                                     },

crates/ruff_python_parser/src/snapshots/ruff_python_parser__parser__tests__dict_unpacking.snap

@@ -15,7 +15,11 @@ Dict(
                                 StringLiteral {
                                     range: 1..4,
                                     value: "a",
-                                    unicode: false,
+                                    flags: StringLiteralFlags {
+                                        quote_style: Double,
+                                        prefix: "",
+                                        triple_quoted: false,
+                                    },
                                 },
                             ),
                         },
@@ -32,7 +36,11 @@ Dict(
                                 StringLiteral {
                                     range: 16..19,
                                     value: "d",
-                                    unicode: false,
+                                    flags: StringLiteralFlags {
+                                        quote_style: Double,
+                                        prefix: "",
+                                        triple_quoted: false,
+                                    },
                                 },
                             ),
                         },
@@ -49,7 +57,11 @@ Dict(
                             StringLiteral {
                                 range: 6..9,
                                 value: "b",
-                                unicode: false,
+                                flags: StringLiteralFlags {
+                                    quote_style: Double,
+                                    prefix: "",
+                                    triple_quoted: false,
+                                },
                             },
                         ),
                     },
@@ -70,7 +82,11 @@ Dict(
                             StringLiteral {
                                 range: 21..24,
                                 value: "e",
-                                unicode: false,
+                                flags: StringLiteralFlags {
+                                    quote_style: Double,
+                                    prefix: "",
+                                    triple_quoted: false,
+                                },
                             },
                         ),
                     },

crates/ruff_python_parser/src/snapshots/ruff_python_parser__parser__tests__fstrings.snap

@@ -26,7 +26,11 @@ expression: parse_ast
                                                                 StringLiteral {
                                                                     range: 3..7,
                                                                     value: " f",
-                                                                    unicode: false,
+                                                                    flags: StringLiteralFlags {
+                                                                        quote_style: Double,
+                                                                        prefix: "",
+                                                                        triple_quoted: false,
+                                                                    },
                                                                 },
                                                             ),
                                                         },
@@ -38,6 +42,11 @@ expression: parse_ast
                                             },
                                         ),
                                     ],
+                                    flags: FStringFlags {
+                                        quote_style: Double,
+                                        raw: false,
+                                        triple_quoted: false,
+                                    },
                                 },
                             ),
                         ),
@@ -74,6 +83,11 @@ expression: parse_ast
                                             },
                                         ),
                                     ],
+                                    flags: FStringFlags {
+                                        quote_style: Double,
+                                        raw: false,
+                                        triple_quoted: false,
+                                    },
                                 },
                             ),
                         ),
@@ -120,6 +134,11 @@ expression: parse_ast
                                             },
                                         ),
                                     ],
+                                    flags: FStringFlags {
+                                        quote_style: Double,
+                                        raw: false,
+                                        triple_quoted: false,
+                                    },
                                 },
                             ),
                         ),
@@ -180,6 +199,11 @@ expression: parse_ast
                                             },
                                         ),
                                     ],
+                                    flags: FStringFlags {
+                                        quote_style: Double,
+                                        raw: false,
+                                        triple_quoted: false,
+                                    },
                                 },
                             ),
                         ),
@@ -228,7 +252,11 @@ expression: parse_ast
                                                                                     StringLiteral {
                                                                                         range: 46..49,
                                                                                         value: "}",
-                                                                                        unicode: false,
+                                                                                        flags: StringLiteralFlags {
+                                                                                            quote_style: Double,
+                                                                                            prefix: "",
+                                                                                            triple_quoted: false,
+                                                                                        },
                                                                                     },
                                                                                 ),
                                                                             },
@@ -251,6 +279,11 @@ expression: parse_ast
                                             },
                                         ),
                                     ],
+                                    flags: FStringFlags {
+                                        quote_style: Single,
+                                        raw: false,
+                                        triple_quoted: false,
+                                    },
                                 },
                             ),
                         ),
@@ -299,7 +332,11 @@ expression: parse_ast
                                                                                     StringLiteral {
                                                                                         range: 62..65,
                                                                                         value: "{",
-                                                                                        unicode: false,
+                                                                                        flags: StringLiteralFlags {
+                                                                                            quote_style: Double,
+                                                                                            prefix: "",
+                                                                                            triple_quoted: false,
+                                                                                        },
                                                                                     },
                                                                                 ),
                                                                             },
@@ -322,6 +359,11 @@ expression: parse_ast
                                             },
                                         ),
                                     ],
+                                    flags: FStringFlags {
+                                        quote_style: Single,
+                                        raw: false,
+                                        triple_quoted: false,
+                                    },
                                 },
                             ),
                         ),
@@ -363,6 +405,11 @@ expression: parse_ast
                                             },
                                         ),
                                     ],
+                                    flags: FStringFlags {
+                                        quote_style: Double,
+                                        raw: false,
+                                        triple_quoted: false,
+                                    },
                                 },
                             ),
                         ),
@@ -416,6 +463,11 @@ expression: parse_ast
                                             },
                                         ),
                                     ],
+                                    flags: FStringFlags {
+                                        quote_style: Double,
+                                        raw: false,
+                                        triple_quoted: false,
+                                    },
                                 },
                             ),
                         ),
@@ -457,6 +509,11 @@ expression: parse_ast
                                             },
                                         ),
                                     ],
+                                    flags: FStringFlags {
+                                        quote_style: Double,
+                                        raw: false,
+                                        triple_quoted: false,
+                                    },
                                 },
                             ),
                         ),
@@ -516,6 +573,11 @@ expression: parse_ast
                                             },
                                         ),
                                     ],
+                                    flags: FStringFlags {
+                                        quote_style: Double,
+                                        raw: false,
+                                        triple_quoted: false,
+                                    },
                                 },
                             ),
                         ),
@@ -582,6 +644,11 @@ expression: parse_ast
                                                                                 },
                                                                             ),
                                                                         ],
+                                                                        flags: FStringFlags {
+                                                                            quote_style: Double,
+                                                                            raw: false,
+                                                                            triple_quoted: false,
+                                                                        },
                                                                     },
                                                                 ),
                                                             ),
@@ -606,6 +673,11 @@ expression: parse_ast
                                             },
                                         ),
                                     ],
+                                    flags: FStringFlags {
+                                        quote_style: Single,
+                                        raw: false,
+                                        triple_quoted: false,
+                                    },
                                 },
                             ),
                         ),
@@ -632,7 +704,11 @@ expression: parse_ast
                                                     StringLiteral {
                                                         range: 173..179,
                                                         value: "foo ",
-                                                        unicode: false,
+                                                        flags: StringLiteralFlags {
+                                                            quote_style: Double,
+                                                            prefix: "",
+                                                            triple_quoted: false,
+                                                        },
                                                     },
                                                 ),
                                                 FString(
@@ -680,13 +756,22 @@ expression: parse_ast
                                                                 },
                                                             ),
                                                         ],
+                                                        flags: FStringFlags {
+                                                            quote_style: Double,
+                                                            raw: false,
+                                                            triple_quoted: false,
+                                                        },
                                                     },
                                                 ),
                                                 Literal(
                                                     StringLiteral {
                                                         range: 196..201,
                                                         value: "baz",
-                                                        unicode: false,
+                                                        flags: StringLiteralFlags {
+                                                            quote_style: Double,
+                                                            prefix: "",
+                                                            triple_quoted: false,
+                                                        },
                                                     },
                                                 ),
                                             ],
@@ -734,7 +819,11 @@ expression: parse_ast
                                             StringLiteral {
                                                 range: 227..232,
                                                 value: "one",
-                                                unicode: false,
+                                                flags: StringLiteralFlags {
+                                                    quote_style: Double,
+                                                    prefix: "",
+                                                    triple_quoted: false,
+                                                },
                                             },
                                         ),
                                     },
@@ -766,12 +855,20 @@ expression: parse_ast
                                                     StringLiteral {
                                                         range: 256..269,
                                                         value: "implicitly ",
-                                                        unicode: false,
+                                                        flags: StringLiteralFlags {
+                                                            quote_style: Double,
+                                                            prefix: "",
+                                                            triple_quoted: false,
+                                                        },
                                                     },
                                                     StringLiteral {
                                                         range: 270..284,
                                                         value: "concatenated",
-                                                        unicode: false,
+                                                        flags: StringLiteralFlags {
+                                                            quote_style: Double,
+                                                            prefix: "",
+                                                            triple_quoted: false,
+                                                        },
                                                     },
                                                 ],
                                                 value: "implicitly concatenated",
@@ -861,6 +958,11 @@ expression: parse_ast
                                             },
                                         ),
                                     ],
+                                    flags: FStringFlags {
+                                        quote_style: Double,
+                                        raw: false,
+                                        triple_quoted: false,
+                                    },
                                 },
                             ),
                         ),
@@ -888,6 +990,11 @@ expression: parse_ast
                                             },
                                         ),
                                     ],
+                                    flags: FStringFlags {
+                                        quote_style: Double,
+                                        raw: false,
+                                        triple_quoted: false,
+                                    },
                                 },
                             ),
                         ),
@@ -936,6 +1043,11 @@ expression: parse_ast
                                             },
                                         ),
                                     ],
+                                    flags: FStringFlags {
+                                        quote_style: Double,
+                                        raw: false,
+                                        triple_quoted: true,
+                                    },
                                 },
                             ),
                         ),
@@ -977,6 +1089,11 @@ expression: parse_ast
                                             },
                                         ),
                                     ],
+                                    flags: FStringFlags {
+                                        quote_style: Double,
+                                        raw: false,
+                                        triple_quoted: false,
+                                    },
                                 },
                             ),
                         ),

crates/ruff_python_parser/src/snapshots/ruff_python_parser__parser__tests__fstrings_with_unicode.snap

@@ -16,7 +16,11 @@ expression: parse_ast
                                     StringLiteral {
                                         range: 0..6,
                                         value: "foo",
-                                        unicode: true,
+                                        flags: StringLiteralFlags {
+                                            quote_style: Double,
+                                            prefix: "u",
+                                            triple_quoted: false,
+                                        },
                                     },
                                 ),
                                 FString(
@@ -39,20 +43,33 @@ expression: parse_ast
                                                 },
                                             ),
                                         ],
+                                        flags: FStringFlags {
+                                            quote_style: Double,
+                                            raw: false,
+                                            triple_quoted: false,
+                                        },
                                     },
                                 ),
                                 Literal(
                                     StringLiteral {
                                         range: 16..21,
                                         value: "baz",
-                                        unicode: false,
+                                        flags: StringLiteralFlags {
+                                            quote_style: Double,
+                                            prefix: "",
+                                            triple_quoted: false,
+                                        },
                                     },
                                 ),
                                 Literal(
                                     StringLiteral {
                                         range: 22..29,
                                         value: " some",
-                                        unicode: false,
+                                        flags: StringLiteralFlags {
+                                            quote_style: Double,
+                                            prefix: "",
+                                            triple_quoted: false,
+                                        },
                                     },
                                 ),
                             ],
@@ -75,7 +92,11 @@ expression: parse_ast
                                     StringLiteral {
                                         range: 30..35,
                                         value: "foo",
-                                        unicode: false,
+                                        flags: StringLiteralFlags {
+                                            quote_style: Double,
+                                            prefix: "",
+                                            triple_quoted: false,
+                                        },
                                     },
                                 ),
                                 FString(
@@ -98,20 +119,33 @@ expression: parse_ast
                                                 },
                                             ),
                                         ],
+                                        flags: FStringFlags {
+                                            quote_style: Double,
+                                            raw: false,
+                                            triple_quoted: false,
+                                        },
                                     },
                                 ),
                                 Literal(
                                     StringLiteral {
                                         range: 45..51,
                                         value: "baz",
-                                        unicode: true,
+                                        flags: StringLiteralFlags {
+                                            quote_style: Double,
+                                            prefix: "u",
+                                            triple_quoted: false,
+                                        },
                                     },
                                 ),
                                 Literal(
                                     StringLiteral {
                                         range: 52..59,
                                         value: " some",
-                                        unicode: false,
+                                        flags: StringLiteralFlags {
+                                            quote_style: Double,
+                                            prefix: "",
+                                            triple_quoted: false,
+                                        },
                                     },
                                 ),
                             ],
@@ -134,7 +168,11 @@ expression: parse_ast
                                     StringLiteral {
                                         range: 60..65,
                                         value: "foo",
-                                        unicode: false,
+                                        flags: StringLiteralFlags {
+                                            quote_style: Double,
+                                            prefix: "",
+                                            triple_quoted: false,
+                                        },
                                     },
                                 ),
                                 FString(
@@ -157,20 +195,33 @@ expression: parse_ast
                                                 },
                                             ),
                                         ],
+                                        flags: FStringFlags {
+                                            quote_style: Double,
+                                            raw: false,
+                                            triple_quoted: false,
+                                        },
                                     },
                                 ),
                                 Literal(
                                     StringLiteral {
                                         range: 75..80,
                                         value: "baz",
-                                        unicode: false,
+                                        flags: StringLiteralFlags {
+                                            quote_style: Double,
+                                            prefix: "",
+                                            triple_quoted: false,
+                                        },
                                     },
                                 ),
                                 Literal(
                                     StringLiteral {
                                         range: 81..89,
                                         value: " some",
-                                        unicode: true,
+                                        flags: StringLiteralFlags {
+                                            quote_style: Double,
+                                            prefix: "u",
+                                            triple_quoted: false,
+                                        },
                                     },
                                 ),
                             ],
@@ -193,7 +244,11 @@ expression: parse_ast
                                     StringLiteral {
                                         range: 90..96,
                                         value: "foo",
-                                        unicode: true,
+                                        flags: StringLiteralFlags {
+                                            quote_style: Double,
+                                            prefix: "u",
+                                            triple_quoted: false,
+                                        },
                                     },
                                 ),
                                 FString(
@@ -228,20 +283,33 @@ expression: parse_ast
                                                 },
                                             ),
                                         ],
+                                        flags: FStringFlags {
+                                            quote_style: Double,
+                                            raw: false,
+                                            triple_quoted: false,
+                                        },
                                     },
                                 ),
                                 Literal(
                                     StringLiteral {
                                         range: 117..123,
                                         value: "bar",
-                                        unicode: true,
+                                        flags: StringLiteralFlags {
+                                            quote_style: Double,
+                                            prefix: "u",
+                                            triple_quoted: false,
+                                        },
                                     },
                                 ),
                                 Literal(
                                     StringLiteral {
                                         range: 124..128,
                                         value: "no",
-                                        unicode: false,
+                                        flags: StringLiteralFlags {
+                                            quote_style: Double,
+                                            prefix: "",
+                                            triple_quoted: false,
+                                        },
                                     },
                                 ),
                             ],

crates/ruff_python_parser/src/snapshots/ruff_python_parser__parser__tests__generator_expression_argument.snap

@@ -16,7 +16,11 @@ Call(
                                 StringLiteral {
                                     range: 0..3,
                                     value: " ",
-                                    unicode: false,
+                                    flags: StringLiteralFlags {
+                                        quote_style: Single,
+                                        prefix: "",
+                                        triple_quoted: false,
+                                    },
                                 },
                             ),
                         },
@@ -77,7 +81,11 @@ Call(
                                                                             StringLiteral {
                                                                                 range: 43..53,
                                                                                 value: "LIMIT %d",
-                                                                                unicode: false,
+                                                                                flags: StringLiteralFlags {
+                                                                                    quote_style: Double,
+                                                                                    prefix: "",
+                                                                                    triple_quoted: false,
+                                                                                },
                                                                             },
                                                                         ),
                                                                     },
@@ -121,7 +129,11 @@ Call(
                                                                             StringLiteral {
                                                                                 range: 91..102,
                                                                                 value: "OFFSET %d",
-                                                                                unicode: false,
+                                                                                flags: StringLiteralFlags {
+                                                                                    quote_style: Double,
+                                                                                    prefix: "",
+                                                                                    triple_quoted: false,
+                                                                                },
                                                                             },
                                                                         ),
                                                                     },

crates/ruff_python_parser/src/snapshots/ruff_python_parser__parser__tests__match.snap

@@ -19,7 +19,11 @@ expression: parse_ast
                                             StringLiteral {
                                                 range: 8..14,
                                                 value: "test",
-                                                unicode: false,
+                                                flags: StringLiteralFlags {
+                                                    quote_style: Double,
+                                                    prefix: "",
+                                                    triple_quoted: false,
+                                                },
                                             },
                                         ),
                                     },
@@ -108,7 +112,11 @@ expression: parse_ast
                                             StringLiteral {
                                                 range: 81..88,
                                                 value: "label",
-                                                unicode: false,
+                                                flags: StringLiteralFlags {
+                                                    quote_style: Double,
+                                                    prefix: "",
+                                                    triple_quoted: false,
+                                                },
                                             },
                                         ),
                                     },
@@ -125,7 +133,11 @@ expression: parse_ast
                                         StringLiteral {
                                             range: 90..96,
                                             value: "test",
-                                            unicode: false,
+                                            flags: StringLiteralFlags {
+                                                quote_style: Double,
+                                                prefix: "",
+                                                triple_quoted: false,
+                                            },
                                         },
                                     ),
                                 },
@@ -149,7 +161,11 @@ expression: parse_ast
                                                 StringLiteral {
                                                     range: 118..125,
                                                     value: "label",
-                                                    unicode: false,
+                                                    flags: StringLiteralFlags {
+                                                        quote_style: Double,
+                                                        prefix: "",
+                                                        triple_quoted: false,
+                                                    },
                                                 },
                                             ),
                                         },

crates/ruff_python_parser/src/snapshots/ruff_python_parser__parser__tests__parse_class.snap

@@ -1,6 +1,6 @@
 ---
 source: crates/ruff_python_parser/src/parser.rs
-expression: "parse_suite(source, \"<test>\").unwrap()"
+expression: parse_suite(source).unwrap()
 ---
 [
     ClassDef(
@@ -121,7 +121,11 @@ expression: "parse_suite(source, \"<test>\").unwrap()"
                                                         StringLiteral {
                                                             range: 80..89,
                                                             value: "default",
-                                                            unicode: false,
+                                                            flags: StringLiteralFlags {
+                                                                quote_style: Single,
+                                                                prefix: "",
+                                                                triple_quoted: false,
+                                                            },
                                                         },
                                                     ),
                                                 },

crates/ruff_python_parser/src/snapshots/ruff_python_parser__parser__tests__parse_f_string.snap

@@ -22,6 +22,11 @@ expression: parse_ast
                                             },
                                         ),
                                     ],
+                                    flags: FStringFlags {
+                                        quote_style: Single,
+                                        raw: false,
+                                        triple_quoted: false,
+                                    },
                                 },
                             ),
                         ),

crates/ruff_python_parser/src/snapshots/ruff_python_parser__parser__tests__parse_kwargs.snap

@@ -27,7 +27,11 @@ expression: parse_ast
                                             StringLiteral {
                                                 range: 8..20,
                                                 value: "positional",
-                                                unicode: false,
+                                                flags: StringLiteralFlags {
+                                                    quote_style: Single,
+                                                    prefix: "",
+                                                    triple_quoted: false,
+                                                },
                                             },
                                         ),
                                     },

crates/ruff_python_parser/src/snapshots/ruff_python_parser__parser__tests__parse_print_2.snap

@@ -27,7 +27,11 @@ expression: parse_ast
                                             StringLiteral {
                                                 range: 6..19,
                                                 value: "Hello world",
-                                                unicode: false,
+                                                flags: StringLiteralFlags {
+                                                    quote_style: Single,
+                                                    prefix: "",
+                                                    triple_quoted: false,
+                                                },
                                             },
                                         ),
                                     },

crates/ruff_python_parser/src/snapshots/ruff_python_parser__parser__tests__parse_print_hello.snap

@@ -27,7 +27,11 @@ expression: parse_ast
                                             StringLiteral {
                                                 range: 6..19,
                                                 value: "Hello world",
-                                                unicode: false,
+                                                flags: StringLiteralFlags {
+                                                    quote_style: Single,
+                                                    prefix: "",
+                                                    triple_quoted: false,
+                                                },
                                             },
                                         ),
                                     },

crates/ruff_python_parser/src/snapshots/ruff_python_parser__parser__tests__parse_string.snap

@@ -14,7 +14,11 @@ expression: parse_ast
                             StringLiteral {
                                 range: 0..13,
                                 value: "Hello world",
-                                unicode: false,
+                                flags: StringLiteralFlags {
+                                    quote_style: Single,
+                                    prefix: "",
+                                    triple_quoted: false,
+                                },
                             },
                         ),
                     },

crates/ruff_python_parser/src/snapshots/ruff_python_parser__parser__tests__parse_type_declaration.snap

@@ -86,7 +86,11 @@ expression: parse_suite(source).unwrap()
                                     StringLiteral {
                                         range: 48..61,
                                         value: "ForwardRefY",
-                                        unicode: false,
+                                        flags: StringLiteralFlags {
+                                            quote_style: Double,
+                                            prefix: "",
+                                            triple_quoted: false,
+                                        },
                                     },
                                 ),
                             },

crates/ruff_python_parser/src/snapshots/ruff_python_parser__parser__tests__patma.snap

@@ -506,7 +506,11 @@ expression: parse_ast
                                                     StringLiteral {
                                                         range: 484..489,
                                                         value: "seq",
-                                                        unicode: false,
+                                                        flags: StringLiteralFlags {
+                                                            quote_style: Double,
+                                                            prefix: "",
+                                                            triple_quoted: false,
+                                                        },
                                                     },
                                                 ),
                                             },
@@ -541,7 +545,11 @@ expression: parse_ast
                                                     StringLiteral {
                                                         range: 518..523,
                                                         value: "map",
-                                                        unicode: false,
+                                                        flags: StringLiteralFlags {
+                                                            quote_style: Double,
+                                                            prefix: "",
+                                                            triple_quoted: false,
+                                                        },
                                                     },
                                                 ),
                                             },
@@ -838,7 +846,11 @@ expression: parse_ast
                                                         StringLiteral {
                                                             range: 664..667,
                                                             value: "X",
-                                                            unicode: false,
+                                                            flags: StringLiteralFlags {
+                                                                quote_style: Double,
+                                                                prefix: "",
+                                                                triple_quoted: false,
+                                                            },
                                                         },
                                                     ),
                                                 },
@@ -1574,7 +1586,11 @@ expression: parse_ast
                                                 StringLiteral {
                                                     range: 1287..1292,
                                                     value: "foo",
-                                                    unicode: false,
+                                                    flags: StringLiteralFlags {
+                                                        quote_style: Double,
+                                                        prefix: "",
+                                                        triple_quoted: false,
+                                                    },
                                                 },
                                             ),
                                         },
@@ -2500,7 +2516,11 @@ expression: parse_ast
                                                         StringLiteral {
                                                             range: 2036..2038,
                                                             value: "",
-                                                            unicode: false,
+                                                            flags: StringLiteralFlags {
+                                                                quote_style: Double,
+                                                                prefix: "",
+                                                                triple_quoted: false,
+                                                            },
                                                         },
                                                     ),
                                                 },
@@ -2550,7 +2570,11 @@ expression: parse_ast
                                             StringLiteral {
                                                 range: 2064..2066,
                                                 value: "",
-                                                unicode: false,
+                                                flags: StringLiteralFlags {
+                                                    quote_style: Double,
+                                                    prefix: "",
+                                                    triple_quoted: false,
+                                                },
                                             },
                                         ),
                                     },
@@ -3174,7 +3198,11 @@ expression: parse_ast
                                                         StringLiteral {
                                                             range: 2449..2452,
                                                             value: "X",
-                                                            unicode: false,
+                                                            flags: StringLiteralFlags {
+                                                                quote_style: Double,
+                                                                prefix: "",
+                                                                triple_quoted: false,
+                                                            },
                                                         },
                                                     ),
                                                 },

crates/ruff_python_parser/src/snapshots/ruff_python_parser__parser__tests__try.snap

@@ -127,6 +127,11 @@ expression: parse_ast
                                                                                     },
                                                                                 ),
                                                                             ],
+                                                                            flags: FStringFlags {
+                                                                                quote_style: Single,
+                                                                                raw: false,
+                                                                                triple_quoted: false,
+                                                                            },
                                                                         },
                                                                     ),
                                                                 ),
@@ -227,6 +232,11 @@ expression: parse_ast
                                                                                     },
                                                                                 ),
                                                                             ],
+                                                                            flags: FStringFlags {
+                                                                                quote_style: Single,
+                                                                                raw: false,
+                                                                                triple_quoted: false,
+                                                                            },
                                                                         },
                                                                     ),
                                                                 ),

crates/ruff_python_parser/src/snapshots/ruff_python_parser__parser__tests__try_star.snap

@@ -32,7 +32,11 @@ expression: parse_ast
                                                             StringLiteral {
                                                                 range: 30..34,
                                                                 value: "eg",
-                                                                unicode: false,
+                                                                flags: StringLiteralFlags {
+                                                                    quote_style: Double,
+                                                                    prefix: "",
+                                                                    triple_quoted: false,
+                                                                },
                                                             },
                                                         ),
                                                     },
@@ -276,6 +280,11 @@ expression: parse_ast
                                                                                     },
                                                                                 ),
                                                                             ],
+                                                                            flags: FStringFlags {
+                                                                                quote_style: Single,
+                                                                                raw: false,
+                                                                                triple_quoted: false,
+                                                                            },
                                                                         },
                                                                     ),
                                                                 ),
@@ -407,6 +416,11 @@ expression: parse_ast
                                                                                     },
                                                                                 ),
                                                                             ],
+                                                                            flags: FStringFlags {
+                                                                                quote_style: Single,
+                                                                                raw: false,
+                                                                                triple_quoted: false,
+                                                                            },
                                                                         },
                                                                     ),
                                                                 ),

crates/ruff_python_parser/src/snapshots/ruff_python_parser__parser__tests__unicode_aliases.snap

@@ -23,7 +23,11 @@ expression: parse_ast
                             StringLiteral {
                                 range: 4..37,
                                 value: "\u{8}another cool trick",
-                                unicode: false,
+                                flags: StringLiteralFlags {
+                                    quote_style: Double,
+                                    prefix: "",
+                                    triple_quoted: false,
+                                },
                             },
                         ),
                     },

crates/ruff_python_parser/src/snapshots/ruff_python_parser__string__tests__backspace_alias.snap

@@ -14,7 +14,11 @@ expression: parse_ast
                             StringLiteral {
                                 range: 0..15,
                                 value: "\u{8}",
-                                unicode: false,
+                                flags: StringLiteralFlags {
+                                    quote_style: Double,
+                                    prefix: "",
+                                    triple_quoted: false,
+                                },
                             },
                         ),
                     },

crates/ruff_python_parser/src/snapshots/ruff_python_parser__string__tests__bell_alias.snap

@@ -14,7 +14,11 @@ expression: parse_ast
                             StringLiteral {
                                 range: 0..9,
                                 value: "\u{7}",
-                                unicode: false,
+                                flags: StringLiteralFlags {
+                                    quote_style: Double,
+                                    prefix: "",
+                                    triple_quoted: false,
+                                },
                             },
                         ),
                     },

crates/ruff_python_parser/src/snapshots/ruff_python_parser__string__tests__carriage_return_alias.snap

@@ -14,7 +14,11 @@ expression: parse_ast
                             StringLiteral {
                                 range: 0..21,
                                 value: "\r",
-                                unicode: false,
+                                flags: StringLiteralFlags {
+                                    quote_style: Double,
+                                    prefix: "",
+                                    triple_quoted: false,
+                                },
                             },
                         ),
                     },

crates/ruff_python_parser/src/snapshots/ruff_python_parser__string__tests__character_tabulation_with_justification_alias.snap

@@ -14,7 +14,11 @@ expression: parse_ast
                             StringLiteral {
                                 range: 0..45,
                                 value: "\u{89}",
-                                unicode: false,
+                                flags: StringLiteralFlags {
+                                    quote_style: Double,
+                                    prefix: "",
+                                    triple_quoted: false,
+                                },
                             },
                         ),
                     },

crates/ruff_python_parser/src/snapshots/ruff_python_parser__string__tests__delete_alias.snap

@@ -14,7 +14,11 @@ expression: parse_ast
                             StringLiteral {
                                 range: 0..12,
                                 value: "\u{7f}",
-                                unicode: false,
+                                flags: StringLiteralFlags {
+                                    quote_style: Double,
+                                    prefix: "",
+                                    triple_quoted: false,
+                                },
                             },
                         ),
                     },

crates/ruff_python_parser/src/snapshots/ruff_python_parser__string__tests__dont_panic_on_8_in_octal_escape.snap

@@ -23,7 +23,11 @@ expression: parse_ast
                             StringLiteral {
                                 range: 7..16,
                                 value: "\u{3}8[1m",
-                                unicode: false,
+                                flags: StringLiteralFlags {
+                                    quote_style: Single,
+                                    prefix: "",
+                                    triple_quoted: false,
+                                },
                             },
                         ),
                     },

crates/ruff_python_parser/src/snapshots/ruff_python_parser__string__tests__double_quoted_byte.snap

@@ -271,6 +271,11 @@ expression: parse_ast
                                     254,
                                     255,
                                 ],
+                                flags: BytesLiteralFlags {
+                                    quote_style: Double,
+                                    raw: false,
+                                    triple_quoted: false,
+                                },
                             },
                         ),
                     },

crates/ruff_python_parser/src/snapshots/ruff_python_parser__string__tests__escape_alias.snap

@@ -14,7 +14,11 @@ expression: parse_ast
                             StringLiteral {
                                 range: 0..12,
                                 value: "\u{1b}",
-                                unicode: false,
+                                flags: StringLiteralFlags {
+                                    quote_style: Double,
+                                    prefix: "",
+                                    triple_quoted: false,
+                                },
                             },
                         ),
                     },

crates/ruff_python_parser/src/snapshots/ruff_python_parser__string__tests__escape_char_in_byte_literal.snap

@@ -25,6 +25,11 @@ expression: parse_ast
                                     97,
                                     97,
                                 ],
+                                flags: BytesLiteralFlags {
+                                    quote_style: Double,
+                                    raw: false,
+                                    triple_quoted: false,
+                                },
                             },
                         ),
                     },

crates/ruff_python_parser/src/snapshots/ruff_python_parser__string__tests__escape_octet.snap

@@ -20,6 +20,11 @@ expression: parse_ast
                                     83,
                                     52,
                                 ],
+                                flags: BytesLiteralFlags {
+                                    quote_style: Single,
+                                    raw: false,
+                                    triple_quoted: false,
+                                },
                             },
                         ),
                     },

crates/ruff_python_parser/src/snapshots/ruff_python_parser__string__tests__form_feed_alias.snap

@@ -14,7 +14,11 @@ expression: parse_ast
                             StringLiteral {
                                 range: 0..15,
                                 value: "\u{c}",
-                                unicode: false,
+                                flags: StringLiteralFlags {
+                                    quote_style: Double,
+                                    prefix: "",
+                                    triple_quoted: false,
+                                },
                             },
                         ),
                     },

crates/ruff_python_parser/src/snapshots/ruff_python_parser__string__tests__fstring_constant_range.snap

@@ -64,6 +64,11 @@ expression: parse_ast
                                             },
                                         ),
                                     ],
+                                    flags: FStringFlags {
+                                        quote_style: Double,
+                                        raw: false,
+                                        triple_quoted: false,
+                                    },
                                 },
                             ),
                         ),

crates/ruff_python_parser/src/snapshots/ruff_python_parser__string__tests__fstring_escaped_character.snap

@@ -37,6 +37,11 @@ expression: parse_ast
                                             },
                                         ),
                                     ],
+                                    flags: FStringFlags {
+                                        quote_style: Double,
+                                        raw: false,
+                                        triple_quoted: false,
+                                    },
                                 },
                             ),
                         ),

crates/ruff_python_parser/src/snapshots/ruff_python_parser__string__tests__fstring_escaped_newline.snap

@@ -37,6 +37,11 @@ expression: parse_ast
                                             },
                                         ),
                                     ],
+                                    flags: FStringFlags {
+                                        quote_style: Double,
+                                        raw: false,
+                                        triple_quoted: false,
+                                    },
                                 },
                             ),
                         ),

crates/ruff_python_parser/src/snapshots/ruff_python_parser__string__tests__fstring_line_continuation.snap

@@ -37,6 +37,11 @@ expression: parse_ast
                                             },
                                         ),
                                     ],
+                                    flags: FStringFlags {
+                                        quote_style: Double,
+                                        raw: true,
+                                        triple_quoted: false,
+                                    },
                                 },
                             ),
                         ),

crates/ruff_python_parser/src/snapshots/ruff_python_parser__string__tests__fstring_parse_self_documenting_base.snap

@@ -36,6 +36,11 @@ expression: parse_ast
                                             },
                                         ),
                                     ],
+                                    flags: FStringFlags {
+                                        quote_style: Double,
+                                        raw: false,
+                                        triple_quoted: false,
+                                    },
                                 },
                             ),
                         ),

crates/ruff_python_parser/src/snapshots/ruff_python_parser__string__tests__fstring_parse_self_documenting_base_more.snap

@@ -68,6 +68,11 @@ expression: parse_ast
                                             },
                                         ),
                                     ],
+                                    flags: FStringFlags {
+                                        quote_style: Double,
+                                        raw: false,
+                                        triple_quoted: false,
+                                    },
                                 },
                             ),
                         ),

crates/ruff_python_parser/src/snapshots/ruff_python_parser__string__tests__fstring_parse_self_documenting_format.snap

@@ -48,6 +48,11 @@ expression: parse_ast
                                             },
                                         ),
                                     ],
+                                    flags: FStringFlags {
+                                        quote_style: Double,
+                                        raw: false,
+                                        triple_quoted: false,
+                                    },
                                 },
                             ),
                         ),

crates/ruff_python_parser/src/snapshots/ruff_python_parser__string__tests__fstring_unescaped_newline.snap

@@ -37,6 +37,11 @@ expression: parse_ast
                                             },
                                         ),
                                     ],
+                                    flags: FStringFlags {
+                                        quote_style: Double,
+                                        raw: false,
+                                        triple_quoted: true,
+                                    },
                                 },
                             ),
                         ),

crates/ruff_python_parser/src/snapshots/ruff_python_parser__string__tests__hts_alias.snap

@@ -14,7 +14,11 @@ expression: parse_ast
                             StringLiteral {
                                 range: 0..9,
                                 value: "\u{88}",
-                                unicode: false,
+                                flags: StringLiteralFlags {
+                                    quote_style: Double,
+                                    prefix: "",
+                                    triple_quoted: false,
+                                },
                             },
                         ),
                     },

crates/ruff_python_parser/src/snapshots/ruff_python_parser__string__tests__parse_empty_fstring.snap

@@ -1,6 +1,6 @@
 ---
 source: crates/ruff_python_parser/src/string.rs
-expression: "parse_suite(r#\"f\"\"\"#, \"<test>\").unwrap()"
+expression: "parse_suite(r#\"f\"\"\"#).unwrap()"
 ---
 [
     Expr(
@@ -15,6 +15,11 @@ expression: "parse_suite(r#\"f\"\"\"#, \"<test>\").unwrap()"
                                 FString {
                                     range: 0..3,
                                     elements: [],
+                                    flags: FStringFlags {
+                                        quote_style: Double,
+                                        raw: false,
+                                        triple_quoted: false,
+                                    },
                                 },
                             ),
                         ),

crates/ruff_python_parser/src/snapshots/ruff_python_parser__string__tests__parse_f_string_concat_1.snap

@@ -16,7 +16,11 @@ expression: parse_ast
                                     StringLiteral {
                                         range: 0..8,
                                         value: "Hello ",
-                                        unicode: false,
+                                        flags: StringLiteralFlags {
+                                            quote_style: Single,
+                                            prefix: "",
+                                            triple_quoted: false,
+                                        },
                                     },
                                 ),
                                 FString(
@@ -30,6 +34,11 @@ expression: parse_ast
                                                 },
                                             ),
                                         ],
+                                        flags: FStringFlags {
+                                            quote_style: Single,
+                                            raw: false,
+                                            triple_quoted: false,
+                                        },
                                     },
                                 ),
                             ],

crates/ruff_python_parser/src/snapshots/ruff_python_parser__string__tests__parse_f_string_concat_2.snap

@@ -16,7 +16,11 @@ expression: parse_ast
                                     StringLiteral {
                                         range: 0..8,
                                         value: "Hello ",
-                                        unicode: false,
+                                        flags: StringLiteralFlags {
+                                            quote_style: Single,
+                                            prefix: "",
+                                            triple_quoted: false,
+                                        },
                                     },
                                 ),
                                 FString(
@@ -30,6 +34,11 @@ expression: parse_ast
                                                 },
                                             ),
                                         ],
+                                        flags: FStringFlags {
+                                            quote_style: Single,
+                                            raw: false,
+                                            triple_quoted: false,
+                                        },
                                     },
                                 ),
                             ],

crates/ruff_python_parser/src/snapshots/ruff_python_parser__string__tests__parse_f_string_concat_3.snap

@@ -16,7 +16,11 @@ expression: parse_ast
                                     StringLiteral {
                                         range: 0..8,
                                         value: "Hello ",
-                                        unicode: false,
+                                        flags: StringLiteralFlags {
+                                            quote_style: Single,
+                                            prefix: "",
+                                            triple_quoted: false,
+                                        },
                                     },
                                 ),
                                 FString(
@@ -40,7 +44,11 @@ expression: parse_ast
                                                                     StringLiteral {
                                                                         range: 17..20,
                                                                         value: "!",
-                                                                        unicode: false,
+                                                                        flags: StringLiteralFlags {
+                                                                            quote_style: Double,
+                                                                            prefix: "",
+                                                                            triple_quoted: false,
+                                                                        },
                                                                     },
                                                                 ),
                                                             },
@@ -52,6 +60,11 @@ expression: parse_ast
                                                 },
                                             ),
                                         ],
+                                        flags: FStringFlags {
+                                            quote_style: Single,
+                                            raw: false,
+                                            triple_quoted: false,
+                                        },
                                     },
                                 ),
                             ],

crates/ruff_python_parser/src/snapshots/ruff_python_parser__string__tests__parse_f_string_concat_4.snap

@@ -16,7 +16,11 @@ expression: parse_ast
                                     StringLiteral {
                                         range: 0..8,
                                         value: "Hello ",
-                                        unicode: false,
+                                        flags: StringLiteralFlags {
+                                            quote_style: Single,
+                                            prefix: "",
+                                            triple_quoted: false,
+                                        },
                                     },
                                 ),
                                 FString(
@@ -40,7 +44,11 @@ expression: parse_ast
                                                                     StringLiteral {
                                                                         range: 17..20,
                                                                         value: "!",
-                                                                        unicode: false,
+                                                                        flags: StringLiteralFlags {
+                                                                            quote_style: Double,
+                                                                            prefix: "",
+                                                                            triple_quoted: false,
+                                                                        },
                                                                     },
                                                                 ),
                                                             },
@@ -52,13 +60,22 @@ expression: parse_ast
                                                 },
                                             ),
                                         ],
+                                        flags: FStringFlags {
+                                            quote_style: Single,
+                                            raw: false,
+                                            triple_quoted: false,
+                                        },
                                     },
                                 ),
                                 Literal(
                                     StringLiteral {
                                         range: 23..31,
                                         value: "again!",
-                                        unicode: false,
+                                        flags: StringLiteralFlags {
+                                            quote_style: Single,
+                                            prefix: "",
+                                            triple_quoted: false,
+                                        },
                                     },
                                 ),
                             ],

crates/ruff_python_parser/src/snapshots/ruff_python_parser__string__tests__parse_fstring.snap

@@ -52,6 +52,11 @@ expression: parse_ast
                                             },
                                         ),
                                     ],
+                                    flags: FStringFlags {
+                                        quote_style: Double,
+                                        raw: false,
+                                        triple_quoted: false,
+                                    },
                                 },
                             ),
                         ),

crates/ruff_python_parser/src/snapshots/ruff_python_parser__string__tests__parse_fstring_equals.snap

@@ -50,6 +50,11 @@ expression: parse_ast
                                             },
                                         ),
                                     ],
+                                    flags: FStringFlags {
+                                        quote_style: Double,
+                                        raw: false,
+                                        triple_quoted: false,
+                                    },
                                 },
                             ),
                         ),

crates/ruff_python_parser/src/snapshots/ruff_python_parser__string__tests__parse_fstring_nested_concatenation_string_spec.snap

@@ -44,12 +44,20 @@ expression: parse_ast
                                                                                             StringLiteral {
                                                                                                 range: 8..10,
                                                                                                 value: "",
-                                                                                                unicode: false,
+                                                                                                flags: StringLiteralFlags {
+                                                                                                    quote_style: Single,
+                                                                                                    prefix: "",
+                                                                                                    triple_quoted: false,
+                                                                                                },
                                                                                             },
                                                                                             StringLiteral {
                                                                                                 range: 11..13,
                                                                                                 value: "",
-                                                                                                unicode: false,
+                                                                                                flags: StringLiteralFlags {
+                                                                                                    quote_style: Single,
+                                                                                                    prefix: "",
+                                                                                                    triple_quoted: false,
+                                                                                                },
                                                                                             },
                                                                                         ],
                                                                                         value: "",
@@ -69,6 +77,11 @@ expression: parse_ast
                                             },
                                         ),
                                     ],
+                                    flags: FStringFlags {
+                                        quote_style: Double,
+                                        raw: false,
+                                        triple_quoted: false,
+                                    },
                                 },
                             ),
                         ),

crates/ruff_python_parser/src/snapshots/ruff_python_parser__string__tests__parse_fstring_nested_spec.snap

@@ -52,6 +52,11 @@ expression: parse_ast
                                             },
                                         ),
                                     ],
+                                    flags: FStringFlags {
+                                        quote_style: Double,
+                                        raw: false,
+                                        triple_quoted: false,
+                                    },
                                 },
                             ),
                         ),

crates/ruff_python_parser/src/snapshots/ruff_python_parser__string__tests__parse_fstring_nested_string_spec.snap

@@ -42,7 +42,11 @@ expression: parse_ast
                                                                                     StringLiteral {
                                                                                         range: 8..10,
                                                                                         value: "",
-                                                                                        unicode: false,
+                                                                                        flags: StringLiteralFlags {
+                                                                                            quote_style: Single,
+                                                                                            prefix: "",
+                                                                                            triple_quoted: false,
+                                                                                        },
                                                                                     },
                                                                                 ),
                                                                             },
@@ -59,6 +63,11 @@ expression: parse_ast
                                             },
                                         ),
                                     ],
+                                    flags: FStringFlags {
+                                        quote_style: Double,
+                                        raw: false,
+                                        triple_quoted: false,
+                                    },
                                 },
                             ),
                         ),

crates/ruff_python_parser/src/snapshots/ruff_python_parser__string__tests__parse_fstring_not_equals.snap

@@ -50,6 +50,11 @@ expression: parse_ast
                                             },
                                         ),
                                     ],
+                                    flags: FStringFlags {
+                                        quote_style: Double,
+                                        raw: false,
+                                        triple_quoted: false,
+                                    },
                                 },
                             ),
                         ),

crates/ruff_python_parser/src/snapshots/ruff_python_parser__string__tests__parse_fstring_not_nested_spec.snap

@@ -43,6 +43,11 @@ expression: parse_ast
                                             },
                                         ),
                                     ],
+                                    flags: FStringFlags {
+                                        quote_style: Double,
+                                        raw: false,
+                                        triple_quoted: false,
+                                    },
                                 },
                             ),
                         ),

crates/ruff_python_parser/src/snapshots/ruff_python_parser__string__tests__parse_fstring_self_doc_prec_space.snap

@@ -36,6 +36,11 @@ expression: parse_ast
                                             },
                                         ),
                                     ],
+                                    flags: FStringFlags {
+                                        quote_style: Double,
+                                        raw: false,
+                                        triple_quoted: false,
+                                    },
                                 },
                             ),
                         ),

crates/ruff_python_parser/src/snapshots/ruff_python_parser__string__tests__parse_fstring_self_doc_trailing_space.snap

@@ -36,6 +36,11 @@ expression: parse_ast
                                             },
                                         ),
                                     ],
+                                    flags: FStringFlags {
+                                        quote_style: Double,
+                                        raw: false,
+                                        triple_quoted: false,
+                                    },
                                 },
                             ),
                         ),

crates/ruff_python_parser/src/snapshots/ruff_python_parser__string__tests__parse_fstring_yield_expr.snap

@@ -30,6 +30,11 @@ expression: parse_ast
                                             },
                                         ),
                                     ],
+                                    flags: FStringFlags {
+                                        quote_style: Double,
+                                        raw: false,
+                                        triple_quoted: false,
+                                    },
                                 },
                             ),
                         ),

crates/ruff_python_parser/src/snapshots/ruff_python_parser__string__tests__parse_string_concat.snap

@@ -16,12 +16,20 @@ expression: parse_ast
                                     StringLiteral {
                                         range: 0..8,
                                         value: "Hello ",
-                                        unicode: false,
+                                        flags: StringLiteralFlags {
+                                            quote_style: Single,
+                                            prefix: "",
+                                            triple_quoted: false,
+                                        },
                                     },
                                     StringLiteral {
                                         range: 9..16,
                                         value: "world",
-                                        unicode: false,
+                                        flags: StringLiteralFlags {
+                                            quote_style: Single,
+                                            prefix: "",
+                                            triple_quoted: false,
+                                        },
                                     },
                                 ],
                                 value: "Hello world",

crates/ruff_python_parser/src/snapshots/ruff_python_parser__string__tests__parse_string_triple_quotes_with_kind.snap

@@ -14,7 +14,11 @@ expression: parse_ast
                             StringLiteral {
                                 range: 0..20,
                                 value: "Hello, world!",
-                                unicode: true,
+                                flags: StringLiteralFlags {
+                                    quote_style: Single,
+                                    prefix: "u",
+                                    triple_quoted: true,
+                                },
                             },
                         ),
                     },

crates/ruff_python_parser/src/snapshots/ruff_python_parser__string__tests__parse_u_f_string_concat_1.snap

@@ -16,7 +16,11 @@ expression: parse_ast
                                     StringLiteral {
                                         range: 0..9,
                                         value: "Hello ",
-                                        unicode: true,
+                                        flags: StringLiteralFlags {
+                                            quote_style: Single,
+                                            prefix: "u",
+                                            triple_quoted: false,
+                                        },
                                     },
                                 ),
                                 FString(
@@ -30,6 +34,11 @@ expression: parse_ast
                                                 },
                                             ),
                                         ],
+                                        flags: FStringFlags {
+                                            quote_style: Single,
+                                            raw: false,
+                                            triple_quoted: false,
+                                        },
                                     },
                                 ),
                             ],

crates/ruff_python_parser/src/snapshots/ruff_python_parser__string__tests__parse_u_f_string_concat_2.snap

@@ -16,7 +16,11 @@ expression: parse_ast
                                     StringLiteral {
                                         range: 0..9,
                                         value: "Hello ",
-                                        unicode: true,
+                                        flags: StringLiteralFlags {
+                                            quote_style: Single,
+                                            prefix: "u",
+                                            triple_quoted: false,
+                                        },
                                     },
                                 ),
                                 FString(
@@ -30,13 +34,22 @@ expression: parse_ast
                                                 },
                                             ),
                                         ],
+                                        flags: FStringFlags {
+                                            quote_style: Single,
+                                            raw: false,
+                                            triple_quoted: false,
+                                        },
                                     },
                                 ),
                                 Literal(
                                     StringLiteral {
                                         range: 19..22,
                                         value: "!",
-                                        unicode: false,
+                                        flags: StringLiteralFlags {
+                                            quote_style: Single,
+                                            prefix: "",
+                                            triple_quoted: false,
+                                        },
                                     },
                                 ),
                             ],

crates/ruff_python_parser/src/snapshots/ruff_python_parser__string__tests__parse_u_string_concat_1.snap

@@ -16,12 +16,20 @@ expression: parse_ast
                                     StringLiteral {
                                         range: 0..8,
                                         value: "Hello ",
-                                        unicode: false,
+                                        flags: StringLiteralFlags {
+                                            quote_style: Single,
+                                            prefix: "",
+                                            triple_quoted: false,
+                                        },
                                     },
                                     StringLiteral {
                                         range: 9..17,
                                         value: "world",
-                                        unicode: true,
+                                        flags: StringLiteralFlags {
+                                            quote_style: Single,
+                                            prefix: "u",
+                                            triple_quoted: false,
+                                        },
                                     },
                                 ],
                                 value: "Hello world",

crates/ruff_python_parser/src/snapshots/ruff_python_parser__string__tests__parse_u_string_concat_2.snap

@@ -16,12 +16,20 @@ expression: parse_ast
                                     StringLiteral {
                                         range: 0..9,
                                         value: "Hello ",
-                                        unicode: true,
+                                        flags: StringLiteralFlags {
+                                            quote_style: Single,
+                                            prefix: "u",
+                                            triple_quoted: false,
+                                        },
                                     },
                                     StringLiteral {
                                         range: 10..17,
                                         value: "world",
-                                        unicode: false,
+                                        flags: StringLiteralFlags {
+                                            quote_style: Single,
+                                            prefix: "",
+                                            triple_quoted: false,
+                                        },
                                     },
                                 ],
                                 value: "Hello world",

crates/ruff_python_parser/src/snapshots/ruff_python_parser__string__tests__raw_byte_literal_1.snap

@@ -19,6 +19,11 @@ expression: parse_ast
                                     49,
                                     122,
                                 ],
+                                flags: BytesLiteralFlags {
+                                    quote_style: Single,
+                                    raw: true,
+                                    triple_quoted: false,
+                                },
                             },
                         ),
                     },

crates/ruff_python_parser/src/snapshots/ruff_python_parser__string__tests__raw_byte_literal_2.snap

@@ -17,6 +17,11 @@ expression: parse_ast
                                     92,
                                     92,
                                 ],
+                                flags: BytesLiteralFlags {
+                                    quote_style: Single,
+                                    raw: true,
+                                    triple_quoted: false,
+                                },
                             },
                         ),
                     },

crates/ruff_python_parser/src/snapshots/ruff_python_parser__string__tests__raw_fstring.snap

@@ -31,6 +31,11 @@ expression: parse_ast
                                             },
                                         ),
                                     ],
+                                    flags: FStringFlags {
+                                        quote_style: Double,
+                                        raw: true,
+                                        triple_quoted: false,
+                                    },
                                 },
                             ),
                         ),

crates/ruff_python_parser/src/snapshots/ruff_python_parser__string__tests__single_quoted_byte.snap

@@ -271,6 +271,11 @@ expression: parse_ast
                                     254,
                                     255,
                                 ],
+                                flags: BytesLiteralFlags {
+                                    quote_style: Single,
+                                    raw: false,
+                                    triple_quoted: false,
+                                },
                             },
                         ),
                     },

crates/ruff_python_parser/src/snapshots/ruff_python_parser__string__tests__string_parser_escaped_mac_eol.snap

@@ -14,7 +14,11 @@ expression: parse_ast
                             StringLiteral {
                                 range: 0..18,
                                 value: "text more text",
-                                unicode: false,
+                                flags: StringLiteralFlags {
+                                    quote_style: Single,
+                                    prefix: "",
+                                    triple_quoted: false,
+                                },
                             },
                         ),
                     },

crates/ruff_python_parser/src/snapshots/ruff_python_parser__string__tests__string_parser_escaped_unix_eol.snap

@@ -14,7 +14,11 @@ expression: parse_ast
                             StringLiteral {
                                 range: 0..18,
                                 value: "text more text",
-                                unicode: false,
+                                flags: StringLiteralFlags {
+                                    quote_style: Single,
+                                    prefix: "",
+                                    triple_quoted: false,
+                                },
                             },
                         ),
                     },

crates/ruff_python_parser/src/snapshots/ruff_python_parser__string__tests__string_parser_escaped_windows_eol.snap

@@ -14,7 +14,11 @@ expression: parse_ast
                             StringLiteral {
                                 range: 0..19,
                                 value: "text more text",
-                                unicode: false,
+                                flags: StringLiteralFlags {
+                                    quote_style: Single,
+                                    prefix: "",
+                                    triple_quoted: false,
+                                },
                             },
                         ),
                     },

crates/ruff_python_parser/src/snapshots/ruff_python_parser__string__tests__triple_quoted_raw_fstring.snap

@@ -31,6 +31,11 @@ expression: parse_ast
                                             },
                                         ),
                                     ],
+                                    flags: FStringFlags {
+                                        quote_style: Double,
+                                        raw: true,
+                                        triple_quoted: true,
+                                    },
                                 },
                             ),
                         ),

crates/ruff_python_parser/src/string.rs

@@ -308,6 +308,7 @@ impl StringParser {
             return Ok(StringType::Bytes(ast::BytesLiteral {
                 value: self.source.into_boxed_bytes(),
                 range: self.range,
+                flags: self.kind.into(),
             }));
         }
 
@@ -316,6 +317,7 @@ impl StringParser {
             return Ok(StringType::Bytes(ast::BytesLiteral {
                 value: self.source.into_boxed_bytes(),
                 range: self.range,
+                flags: self.kind.into(),
             }));
         };
 
@@ -352,6 +354,7 @@ impl StringParser {
         Ok(StringType::Bytes(ast::BytesLiteral {
             value: value.into_boxed_slice(),
             range: self.range,
+            flags: self.kind.into(),
         }))
     }
 
@@ -360,8 +363,8 @@ impl StringParser {
             // For raw strings, no escaping is necessary.
             return Ok(StringType::Str(ast::StringLiteral {
                 value: self.source,
-                unicode: self.kind.is_u_string(),
                 range: self.range,
+                flags: self.kind.into(),
             }));
         }
 
@@ -369,8 +372,8 @@ impl StringParser {
             // If the string doesn't contain any escape sequences, return the owned string.
             return Ok(StringType::Str(ast::StringLiteral {
                 value: self.source,
-                unicode: self.kind.is_u_string(),
                 range: self.range,
+                flags: self.kind.into(),
             }));
         };
 
@@ -406,8 +409,8 @@ impl StringParser {
 
         Ok(StringType::Str(ast::StringLiteral {
             value: value.into_boxed_str(),
-            unicode: self.kind.is_u_string(),
             range: self.range,
+            flags: self.kind.into(),
         }))
     }
 

crates/ruff_python_parser/src/string_token_flags.rs

@@ -2,6 +2,7 @@ use std::fmt;
 
 use bitflags::bitflags;
 
+use ruff_python_ast::{str::QuoteStyle, StringLiteralPrefix};
 use ruff_text_size::{TextLen, TextSize};
 
 bitflags! {
@@ -287,28 +288,67 @@ impl fmt::Debug for StringKind {
     }
 }
 
-#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
+impl From<StringKind> for ruff_python_ast::StringLiteralFlags {
-pub enum QuoteStyle {
+    fn from(value: StringKind) -> ruff_python_ast::StringLiteralFlags {
-    /// E.g. '
+        debug_assert!(!value.is_f_string());
-    Single,
+        debug_assert!(!value.is_byte_string());
-    /// E.g. "
-    #[default]
-    Double,
-}
 
-impl QuoteStyle {
+        let mut new = ruff_python_ast::StringLiteralFlags::default();
-    pub const fn as_char(self) -> char {
+        if value.quote_style().is_double() {
-        match self {
+            new = new.with_double_quotes();
-            Self::Single => '\'',
+        }
-            Self::Double => '"',
+        if value.is_triple_quoted() {
+            new = new.with_triple_quotes();
+        }
+        new.with_prefix({
+            if value.is_u_string() {
+                debug_assert!(!value.is_raw_string());
+                StringLiteralPrefix::UString
+            } else if value.is_raw_string() {
+                StringLiteralPrefix::RString
+            } else {
+                StringLiteralPrefix::None
+            }
+        })
     }
 }
 
-    #[must_use]
+impl From<StringKind> for ruff_python_ast::BytesLiteralFlags {
-    pub const fn opposite(self) -> Self {
+    fn from(value: StringKind) -> ruff_python_ast::BytesLiteralFlags {
-        match self {
+        debug_assert!(value.is_byte_string());
-            Self::Single => Self::Double,
+        debug_assert!(!value.is_f_string());
-            Self::Double => Self::Single,
+        debug_assert!(!value.is_u_string());
+
+        let mut new = ruff_python_ast::BytesLiteralFlags::default();
+        if value.quote_style().is_double() {
+            new = new.with_double_quotes();
+        }
+        if value.is_triple_quoted() {
+            new = new.with_triple_quotes();
+        }
+        if value.is_raw_string() {
+            new = new.with_r_prefix();
+        }
+        new
     }
 }
+
+impl From<StringKind> for ruff_python_ast::FStringFlags {
+    fn from(value: StringKind) -> ruff_python_ast::FStringFlags {
+        debug_assert!(value.is_f_string());
+        debug_assert!(!value.is_byte_string());
+        debug_assert!(!value.is_u_string());
+
+        let mut new = ruff_python_ast::FStringFlags::default();
+        if value.quote_style().is_double() {
+            new = new.with_double_quotes();
+        }
+        if value.is_triple_quoted() {
+            new = new.with_triple_quotes();
+        }
+        if value.is_raw_string() {
+            new = new.with_r_prefix();
+        }
+        new
+    }
 }