Preserve quote style in generated code

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/rules/flake8_pytest_style/rules/parametrize.rs

@@ -4,8 +4,8 @@ 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_codegen::Generator;
+use ruff_python_ast::{self as ast, Expr, ExprCall, ExprContext, StringLiteralFlags};
+use ruff_python_codegen::{Generator, Stylist};
 use ruff_python_trivia::CommentRanges;
 use ruff_python_trivia::{SimpleTokenKind, SimpleTokenizer};
 use ruff_text_size::{Ranged, TextRange, TextSize};
@@ -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, stylist: &Stylist) -> 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: StringLiteralFlags::from(stylist),
     });
     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: StringLiteralFlags::from(checker.stylist()),
                                     })
                                 })
                                 .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: StringLiteralFlags::from(checker.stylist()),
                                     })
                                 })
                                 .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.stylist())
+                        {
                             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.stylist())
+                        {
                             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,7 @@
 use ruff_python_ast::{
     self as ast, str_prefix::StringLiteralPrefix, Arguments, Expr, StringLiteralFlags,
 };
-use ruff_text_size::Ranged;
+use ruff_text_size::{Ranged, TextRange};
 
 use crate::fix::snippet::SourceCodeSnippet;
 use ruff_diagnostics::{AlwaysFixableViolation, Diagnostic, Edit, Fix, FixAvailability, Violation};
@@ -220,14 +220,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: StringLiteralFlags::from(checker.stylist()).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']

crates/ruff_linter/src/rules/flake8_type_checking/helpers.rs

@@ -366,7 +366,7 @@ impl<'a> QuoteAnnotator<'a> {
         generator.expr(&Expr::from(ast::StringLiteral {
             range: TextRange::default(),
             value: annotation.into_boxed_str(),
-            flags: ast::StringLiteralFlags::default(),
+            flags: ast::StringLiteralFlags::from(self.stylist),
         }))
     }
 

crates/ruff_linter/src/rules/flake8_type_checking/snapshots/ruff_linter__rules__flake8_type_checking__tests__quote_typing-only-third-party-import_quote.py.snap

@@ -201,7 +201,7 @@ quote.py:47:24: TC002 [*] Move third-party import `pandas.DataFrame` into a type
 47    |-    from pandas import DataFrame
 48 51 | 
 49    |-    def baz() -> DataFrame[Literal["int"]]:
-   52 |+    def baz() -> "DataFrame[Literal['int']]":
+   52 |+    def baz() -> 'DataFrame[Literal["int"]]':
 50 53 |         ...
 51 54 | 
 52 55 | 

crates/ruff_linter/src/rules/flake8_type_checking/snapshots/ruff_linter__rules__flake8_type_checking__tests__quote_typing-only-third-party-import_quote2.py.snap

@@ -111,7 +111,7 @@ quote2.py:25:44: TC002 [*] Move third-party import `django.contrib.auth.models.A
 25    |-    from django.contrib.auth.models import AbstractBaseUser
 26 29 | 
 27    |-    def test_literal_annotation_args_contain_quotes(self, type1: AbstractBaseUser[Literal["user", "admin"], Annotated["int", "1", 2]]):
-   30 |+    def test_literal_annotation_args_contain_quotes(self, type1: "AbstractBaseUser[Literal['user', 'admin'], Annotated[int, '1', 2]]"):
+   30 |+    def test_literal_annotation_args_contain_quotes(self, type1: 'AbstractBaseUser[Literal["user", "admin"], Annotated[int, "1", 2]]'):
 28 31 |         pass
 29 32 | 
 30 33 | 
@@ -142,7 +142,7 @@ quote2.py:34:44: TC002 [*] Move third-party import `django.contrib.auth.models.A
 34    |-    from django.contrib.auth.models import AbstractBaseUser
 35 38 | 
 36    |-    def test_union_contain_inner_quotes(self, type1: AbstractBaseUser["int" | Literal["int"]]):
-   39 |+    def test_union_contain_inner_quotes(self, type1: "AbstractBaseUser[int | Literal['int']]"):
+   39 |+    def test_union_contain_inner_quotes(self, type1: 'AbstractBaseUser[int | Literal["int"]]'):
 37 40 |         pass
 38 41 | 
 39 42 | 
@@ -173,7 +173,7 @@ quote2.py:43:44: TC002 [*] Move third-party import `django.contrib.auth.models.A
 43    |-    from django.contrib.auth.models import AbstractBaseUser
 44 47 | 
 45    |-    def test_inner_literal_mixed_quotes(user: AbstractBaseUser[Literal['user', "admin"]]):
-   48 |+    def test_inner_literal_mixed_quotes(user: "AbstractBaseUser[Literal['user', 'admin']]"):
+   48 |+    def test_inner_literal_mixed_quotes(user: "AbstractBaseUser[Literal['user', \"admin\"]]"):
 46 49 |         pass
 47 50 | 
 48 51 | 
@@ -266,7 +266,7 @@ quote2.py:70:44: TC002 [*] Move third-party import `django.contrib.auth.models.A
 70    |-    from django.contrib.auth.models import AbstractBaseUser
 71 74 | 
 72    |-    def test_annotated_literal_mixed_quotes(user: AbstractBaseUser[Annotated[str, "max_length=20", Literal['user', "admin"]]]):
-   75 |+    def test_annotated_literal_mixed_quotes(user: "AbstractBaseUser[Annotated[str, 'max_length=20', Literal['user', 'admin']]]"):
+   75 |+    def test_annotated_literal_mixed_quotes(user: "AbstractBaseUser[Annotated[str, \"max_length=20\", Literal['user', \"admin\"]]]"):
 73 76 |         pass
 74 77 | 
 75 78 |

crates/ruff_linter/src/rules/flake8_type_checking/snapshots/ruff_linter__rules__flake8_type_checking__tests__quote_typing-only-third-party-import_quote3.py.snap

@@ -23,7 +23,7 @@ quote3.py:4:44: TC002 [*] Move third-party import `django.contrib.auth.models.Ab
 4     |-    from django.contrib.auth.models import AbstractBaseUser
 5  8  | 
 6     |-    def test_union_literal_mixed_quotes(user: AbstractBaseUser[Union[Literal['active', "inactive"], str]]):
-   9  |+    def test_union_literal_mixed_quotes(user: 'AbstractBaseUser[Union[Literal["active", "inactive"], str]]'):
+   9  |+    def test_union_literal_mixed_quotes(user: 'AbstractBaseUser[Union[Literal[\'active\', "inactive"], str]]'):
 7  10 |         pass
 8  11 | 
 9  12 | 
@@ -54,7 +54,7 @@ quote3.py:13:44: TC002 [*] Move third-party import `django.contrib.auth.models.A
 13    |-    from django.contrib.auth.models import AbstractBaseUser
 14 17 | 
 15    |-    def test_callable_literal_mixed_quotes(callable_fn: AbstractBaseUser[Callable[["int", Literal['admin', "user"]], 'bool']]):
-   18 |+    def test_callable_literal_mixed_quotes(callable_fn: 'AbstractBaseUser[Callable[[int, Literal["admin", "user"]], bool]]'):
+   18 |+    def test_callable_literal_mixed_quotes(callable_fn: 'AbstractBaseUser[Callable[[int, Literal[\'admin\', "user"]], bool]]'):
 16 19 |         pass
 17 20 | 
 18 21 | 
@@ -85,7 +85,7 @@ quote3.py:22:44: TC002 [*] Move third-party import `django.contrib.auth.models.A
 22    |-    from django.contrib.auth.models import AbstractBaseUser
 23 26 | 
 24    |-    def test_callable_annotated_literal(callable_fn: AbstractBaseUser[Callable[[int, Annotated[str, Literal['active', "inactive"]]], bool]]):
-   27 |+    def test_callable_annotated_literal(callable_fn: 'AbstractBaseUser[Callable[[int, Annotated[str, Literal["active", "inactive"]]], bool]]'):
+   27 |+    def test_callable_annotated_literal(callable_fn: 'AbstractBaseUser[Callable[[int, Annotated[str, Literal[\'active\', "inactive"]]], bool]]'):
 25 28 |         pass
 26 29 | 
 27 30 | 

crates/ruff_linter/src/rules/flake8_type_checking/snapshots/ruff_linter__rules__flake8_type_checking__tests__runtime-cast-value_TC006.py.snap

@@ -110,7 +110,7 @@ TC006.py:52:12: TC006 [*] Add quotes to type expression in `typing.cast()`
 50 50 |     import typing as t
 51 51 | 
 52    |-    t.cast(t.Literal["3.0", '3'], 3.0)  # TC006
-   52 |+    t.cast("t.Literal['3.0', '3']", 3.0)  # TC006
+   52 |+    t.cast("t.Literal[\"3.0\", '3']", 3.0)  # TC006
 53 53 | 
 54 54 | 
 55 55 | def f():
@@ -170,7 +170,7 @@ TC006.py:75:10: TC006 [*] Add quotes to type expression in `typing.cast()`
 73 73 |     from typing import cast, Literal
 74 74 | 
 75    |-    cast(Literal["A"], 'A')
-   75 |+    cast("Literal['A']", 'A')
+   75 |+    cast('Literal["A"]', 'A')
 76 76 | 
 77 77 | 
 78 78 | def f():
@@ -189,7 +189,7 @@ TC006.py:82:10: TC006 [*] Add quotes to type expression in `typing.cast()`
 80 80 |     from typing import cast, Annotated, Literal
 81 81 | 
 82    |-    cast(list[Annotated["list['Literal[\"A\"]']", "Foo"]], ['A'])
-   82 |+    cast("list[Annotated[list[Literal['A']], 'Foo']]", ['A'])
+   82 |+    cast('list[Annotated[list[Literal["A"]], "Foo"]]', ['A'])
 83 83 | 
 84 84 | 
 85 85 | def f():