Preserve quote style in generated code

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

@@ -82,3 +82,11 @@ def __iter__(self) -> Iterator[Union[*_B0]]:
 # Regression test for: https://github.com/astral-sh/ruff/issues/8609
 def f(x: Union[int, str, bytes]) -> None:
     ...
+
+
+# Regression test for https://github.com/astral-sh/ruff/issues/14132
+class AClass:
+    ...
+
+def myfunc(param: "tuple[Union[int, 'AClass', None], str]"):
+    print(param)

crates/ruff_linter/resources/test/fixtures/ruff/RUF055_0.py

@@ -93,3 +93,8 @@ def dashrepl(matchobj):
 
 re.sub(r"a", "\?", "a")
 re.sub(r"a", r"\?", "a")
+
+# these double as tests for preserving raw string quoting style
+re.sub(r'abc', "", s)
+re.sub(r"""abc""", "", s)
+re.sub(r'''abc''', "", s)

crates/ruff_linter/src/checkers/ast/analyze/expression.rs

@@ -506,7 +506,7 @@ pub(crate) fn expression(expr: &Expr, checker: &mut Checker) {
                                     checker,
                                     attr,
                                     call,
-                                    string_value.to_str(),
+                                    string_value,
                                 );
                             }
                         } else if attr == "format" {

crates/ruff_linter/src/checkers/ast/mod.rs

@@ -296,11 +296,23 @@ impl<'a> Checker<'a> {
     pub(crate) fn generator(&self) -> Generator {
         Generator::new(
             self.stylist.indentation(),
-            self.f_string_quote_style().unwrap_or(self.stylist.quote()),
+            self.preferred_quote(),
             self.stylist.line_ending(),
         )
     }
 
+    /// Return the preferred quote for a generated `StringLiteral` node, given where we are in the
+    /// AST.
+    pub(crate) fn preferred_quote(&self) -> Quote {
+        self.f_string_quote_style().unwrap_or(self.stylist.quote())
+    }
+
+    /// Return the default string flags a generated `StringLiteral` node should use, given where we
+    /// are in the AST.
+    pub(crate) fn default_string_flags(&self) -> ast::StringLiteralFlags {
+        ast::StringLiteralFlags::new(self.preferred_quote())
+    }
+
     /// Returns the appropriate quoting for f-string by reversing the one used outside of
     /// the f-string.
     ///

crates/ruff_linter/src/rules/flake8_pytest_style/rules/parametrize.rs

@@ -4,7 +4,7 @@ use ruff_diagnostics::{Diagnostic, Edit, Fix, FixAvailability, Violation};
 use ruff_macros::{derive_message_formats, ViolationMetadata};
 use ruff_python_ast::comparable::ComparableExpr;
 use ruff_python_ast::parenthesize::parenthesized_range;
-use ruff_python_ast::{self as ast, Expr, ExprCall, ExprContext};
+use ruff_python_ast::{self as ast, Expr, ExprCall, ExprContext, StringLiteralFlags};
 use ruff_python_codegen::Generator;
 use ruff_python_trivia::CommentRanges;
 use ruff_python_trivia::{SimpleTokenKind, SimpleTokenizer};
@@ -280,7 +280,7 @@ impl Violation for PytestDuplicateParametrizeTestCases {
     }
 }
 
-fn elts_to_csv(elts: &[Expr], generator: Generator) -> Option<String> {
+fn elts_to_csv(elts: &[Expr], generator: Generator, flags: StringLiteralFlags) -> Option<String> {
     if !elts.iter().all(Expr::is_string_literal_expr) {
         return None;
     }
@@ -298,7 +298,8 @@ fn elts_to_csv(elts: &[Expr], generator: Generator) -> Option<String> {
                 acc
             })
             .into_boxed_str(),
-        ..ast::StringLiteral::default()
+        range: TextRange::default(),
+        flags,
     });
     Some(generator.expr(&node))
 }
@@ -358,8 +359,9 @@ fn check_names(checker: &mut Checker, call: &ExprCall, expr: &Expr, argvalues: &
                                 .iter()
                                 .map(|name| {
                                     Expr::from(ast::StringLiteral {
-                                        value: (*name).to_string().into_boxed_str(),
-                                        ..ast::StringLiteral::default()
+                                        value: Box::from(*name),
+                                        range: TextRange::default(),
+                                        flags: checker.default_string_flags(),
                                     })
                                 })
                                 .collect(),
@@ -393,8 +395,9 @@ fn check_names(checker: &mut Checker, call: &ExprCall, expr: &Expr, argvalues: &
                                 .iter()
                                 .map(|name| {
                                     Expr::from(ast::StringLiteral {
-                                        value: (*name).to_string().into_boxed_str(),
-                                        ..ast::StringLiteral::default()
+                                        value: Box::from(*name),
+                                        range: TextRange::default(),
+                                        flags: checker.default_string_flags(),
                                     })
                                 })
                                 .collect(),
@@ -444,7 +447,9 @@ fn check_names(checker: &mut Checker, call: &ExprCall, expr: &Expr, argvalues: &
                             },
                             expr.range(),
                         );
-                        if let Some(content) = elts_to_csv(elts, checker.generator()) {
+                        if let Some(content) =
+                            elts_to_csv(elts, checker.generator(), checker.default_string_flags())
+                        {
                             diagnostic.set_fix(Fix::unsafe_edit(Edit::range_replacement(
                                 content,
                                 expr.range(),
@@ -489,7 +494,9 @@ fn check_names(checker: &mut Checker, call: &ExprCall, expr: &Expr, argvalues: &
                             },
                             expr.range(),
                         );
-                        if let Some(content) = elts_to_csv(elts, checker.generator()) {
+                        if let Some(content) =
+                            elts_to_csv(elts, checker.generator(), checker.default_string_flags())
+                        {
                             diagnostic.set_fix(Fix::unsafe_edit(Edit::range_replacement(
                                 content,
                                 expr.range(),

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

@@ -1,7 +1,5 @@
-use ruff_python_ast::{
-    self as ast, str_prefix::StringLiteralPrefix, Arguments, Expr, StringLiteralFlags,
-};
-use ruff_text_size::Ranged;
+use ruff_python_ast::{self as ast, str_prefix::StringLiteralPrefix, Arguments, Expr};
+use ruff_text_size::{Ranged, TextRange};
 
 use crate::fix::snippet::SourceCodeSnippet;
 use ruff_diagnostics::{AlwaysFixableViolation, Diagnostic, Edit, Fix, FixAvailability, Violation};
@@ -220,14 +218,14 @@ fn check_os_environ_subscript(checker: &mut Checker, expr: &Expr) {
     );
     let node = ast::StringLiteral {
         value: capital_env_var.into_boxed_str(),
-        flags: StringLiteralFlags::default().with_prefix({
+        flags: checker.default_string_flags().with_prefix({
             if env_var.is_unicode() {
                 StringLiteralPrefix::Unicode
             } else {
                 StringLiteralPrefix::Empty
             }
         }),
-        ..ast::StringLiteral::default()
+        range: TextRange::default(),
     };
     let new_env_var = node.into();
     diagnostic.set_fix(Fix::unsafe_edit(Edit::range_replacement(

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

@@ -62,7 +62,7 @@ pub(crate) fn split_static_string(
     checker: &mut Checker,
     attr: &str,
     call: &ExprCall,
-    str_value: &str,
+    str_value: &StringLiteralValue,
 ) {
     let ExprCall { arguments, .. } = call;
 
@@ -115,16 +115,16 @@ pub(crate) fn split_static_string(
     checker.diagnostics.push(diagnostic);
 }
 
-fn construct_replacement(elts: &[&str]) -> Expr {
+fn construct_replacement(elts: &[&str], flags: StringLiteralFlags) -> Expr {
     Expr::List(ExprList {
         elts: elts
             .iter()
             .map(|elt| {
                 Expr::StringLiteral(ExprStringLiteral {
                     value: StringLiteralValue::single(StringLiteral {
-                        value: (*elt).to_string().into_boxed_str(),
+                        value: Box::from(*elt),
                         range: TextRange::default(),
-                        flags: StringLiteralFlags::default(),
+                        flags,
                     }),
                     range: TextRange::default(),
                 })
@@ -135,7 +135,7 @@ fn construct_replacement(elts: &[&str]) -> Expr {
     })
 }
 
-fn split_default(str_value: &str, max_split: i32) -> Option<Expr> {
+fn split_default(str_value: &StringLiteralValue, max_split: i32) -> Option<Expr> {
     // From the Python documentation:
     // > If sep is not specified or is None, a different splitting algorithm is applied: runs of
     // > consecutive whitespace are regarded as a single separator, and the result will contain
@@ -151,30 +151,36 @@ fn split_default(str_value: &str, max_split: i32) -> Option<Expr> {
             None
         }
         Ordering::Equal => {
-            let list_items: Vec<&str> = vec![str_value];
-            Some(construct_replacement(&list_items))
+            let list_items: Vec<&str> = vec![str_value.to_str()];
+            Some(construct_replacement(&list_items, str_value.flags()))
         }
         Ordering::Less => {
-            let list_items: Vec<&str> = str_value.split_whitespace().collect();
-            Some(construct_replacement(&list_items))
+            let list_items: Vec<&str> = str_value.to_str().split_whitespace().collect();
+            Some(construct_replacement(&list_items, str_value.flags()))
         }
     }
 }
 
-fn split_sep(str_value: &str, sep_value: &str, max_split: i32, direction: Direction) -> Expr {
+fn split_sep(
+    str_value: &StringLiteralValue,
+    sep_value: &str,
+    max_split: i32,
+    direction: Direction,
+) -> Expr {
+    let value = str_value.to_str();
     let list_items: Vec<&str> = if let Ok(split_n) = usize::try_from(max_split) {
         match direction {
-            Direction::Left => str_value.splitn(split_n + 1, sep_value).collect(),
-            Direction::Right => str_value.rsplitn(split_n + 1, sep_value).collect(),
+            Direction::Left => value.splitn(split_n + 1, sep_value).collect(),
+            Direction::Right => value.rsplitn(split_n + 1, sep_value).collect(),
         }
     } else {
         match direction {
-            Direction::Left => str_value.split(sep_value).collect(),
-            Direction::Right => str_value.rsplit(sep_value).collect(),
+            Direction::Left => value.split(sep_value).collect(),
+            Direction::Right => value.rsplit(sep_value).collect(),
         }
     };
 
-    construct_replacement(&list_items)
+    construct_replacement(&list_items, str_value.flags())
 }
 
 /// Returns the value of the `maxsplit` argument as an `i32`, if it is a numeric value.

crates/ruff_linter/src/rules/flake8_simplify/snapshots/ruff_linter__rules__flake8_simplify__tests__SIM905_SIM905.py.snap

@@ -319,7 +319,7 @@ SIM905.py:29:1: SIM905 [*] Consider using a list literal instead of `str.split`
 27 27 | "a,b,c,d".split(maxsplit=0)
 28 28 | "VERB AUX PRON ADP DET".split(" ")
 29    |-'   1   2   3   '.split()
-   29 |+["1", "2", "3"]
+   29 |+['1', '2', '3']
 30 30 | '1<>2<>3<4'.split('<>')
 31 31 | 
 32 32 | " a*a a*a a ".split("*", -1)  # [' a', 'a a', 'a a ']
@@ -340,7 +340,7 @@ SIM905.py:30:1: SIM905 [*] Consider using a list literal instead of `str.split`
 28 28 | "VERB AUX PRON ADP DET".split(" ")
 29 29 | '   1   2   3   '.split()
 30    |-'1<>2<>3<4'.split('<>')
-   30 |+["1", "2", "3<4"]
+   30 |+['1', '2', '3<4']
 31 31 | 
 32 32 | " a*a a*a a ".split("*", -1)  # [' a', 'a a', 'a a ']
 33 33 | "".split()  # []
@@ -569,7 +569,7 @@ SIM905.py:58:1: SIM905 [*] Consider using a list literal instead of `str.split`
 56 56 | 
 57 57 | # prefixes and isc
 58    |-u"a b".split()  # ['a', 'b']
-   58 |+["a", "b"]  # ['a', 'b']
+   58 |+[u"a", u"b"]  # ['a', 'b']
 59 59 | r"a \n b".split()  # ['a', '\\n', 'b']
 60 60 | ("a " "b").split()  # ['a', 'b']
 61 61 | "a " "b".split()  # ['a', 'b']
@@ -590,7 +590,7 @@ SIM905.py:59:1: SIM905 [*] Consider using a list literal instead of `str.split`
 57 57 | # prefixes and isc
 58 58 | u"a b".split()  # ['a', 'b']
 59    |-r"a \n b".split()  # ['a', '\\n', 'b']
-   59 |+["a", "\\n", "b"]  # ['a', '\\n', 'b']
+   59 |+[r"a", r"\n", r"b"]  # ['a', '\\n', 'b']
 60 60 | ("a " "b").split()  # ['a', 'b']
 61 61 | "a " "b".split()  # ['a', 'b']
 62 62 | u"a " "b".split()  # ['a', 'b']
@@ -653,7 +653,7 @@ SIM905.py:62:1: SIM905 [*] Consider using a list literal instead of `str.split`
 60 60 | ("a " "b").split()  # ['a', 'b']
 61 61 | "a " "b".split()  # ['a', 'b']
 62    |-u"a " "b".split()  # ['a', 'b']
-   62 |+["a", "b"]  # ['a', 'b']
+   62 |+[u"a", u"b"]  # ['a', 'b']
 63 63 | "a " u"b".split()  # ['a', 'b']
 64 64 | u"a " r"\n".split()  # ['a', '\\n']
 65 65 | r"\n " u"\n".split()  # ['\\n']
@@ -695,7 +695,7 @@ SIM905.py:64:1: SIM905 [*] Consider using a list literal instead of `str.split`
 62 62 | u"a " "b".split()  # ['a', 'b']
 63 63 | "a " u"b".split()  # ['a', 'b']
 64    |-u"a " r"\n".split()  # ['a', '\\n']
-   64 |+["a", "\\n"]  # ['a', '\\n']
+   64 |+[u"a", u"\\n"]  # ['a', '\\n']
 65 65 | r"\n " u"\n".split()  # ['\\n']
 66 66 | r"\n " "\n".split()  # ['\\n']
 67 67 | "a " r"\n".split()  # ['a', '\\n']
@@ -716,7 +716,7 @@ SIM905.py:65:1: SIM905 [*] Consider using a list literal instead of `str.split`
 63 63 | "a " u"b".split()  # ['a', 'b']
 64 64 | u"a " r"\n".split()  # ['a', '\\n']
 65    |-r"\n " u"\n".split()  # ['\\n']
-   65 |+["\\n"]  # ['\\n']
+   65 |+[r"\n"]  # ['\\n']
 66 66 | r"\n " "\n".split()  # ['\\n']
 67 67 | "a " r"\n".split()  # ['a', '\\n']
 68 68 | 
@@ -736,7 +736,7 @@ SIM905.py:66:1: SIM905 [*] Consider using a list literal instead of `str.split`
 64 64 | u"a " r"\n".split()  # ['a', '\\n']
 65 65 | r"\n " u"\n".split()  # ['\\n']
 66    |-r"\n " "\n".split()  # ['\\n']
-   66 |+["\\n"]  # ['\\n']
+   66 |+[r"\n"]  # ['\\n']
 67 67 | "a " r"\n".split()  # ['a', '\\n']
 68 68 | 
 69 69 | "a,b,c".split(',', maxsplit=0) # ['a,b,c']