Format single string part

crates/ruff_python_ast/src/str.rs

@@ -220,11 +220,15 @@ pub fn is_implicit_concatenation(content: &str) -> bool {
     let mut rest = &content[leading_quote_str.len()..content.len() - trailing_quote_str.len()];
     while let Some(index) = rest.find(trailing_quote_str) {
         let mut chars = rest[..index].chars().rev();
+
         if let Some('\\') = chars.next() {
-            // If the quote is double-escaped, then it's _not_ escaped, so the string is
-            // implicitly concatenated.
-            if let Some('\\') = chars.next() {
-                return true;
+            if chars.next() == Some('\\') {
+                // Either `\\'` or `\\\'` need to test one more character
+
+                // If the quote is preceded by `//` then it is not escaped, instead the backslash is escaped.
+                if chars.next() != Some('\\') {
+                    return true;
+                }
             }
         } else {
             // If the quote is _not_ escaped, then it's implicitly concatenated.
@@ -299,5 +303,6 @@ mod tests {
 
         // Negative cases with escaped quotes.
         assert!(!is_implicit_concatenation(r#""abc\"def""#));
+        assert!(!is_implicit_concatenation(r#"'\\\' ""'"#));
     }
 }

crates/ruff_python_formatter/Cargo.toml

@@ -17,6 +17,7 @@ ruff_python_ast = { path = "../ruff_python_ast" }
 ruff_text_size = { workspace = true }
 
 anyhow = { workspace = true }
+bitflags = { workspace = true }
 clap = { workspace = true }
 countme = "3.0.1"
 is-macro = { workspace = true }

crates/ruff_python_formatter/resources/test/fixtures/ruff/expression/string.py

@@ -0,0 +1,40 @@
+"' test"
+'" test'
+
+"\" test"
+'\' test'
+
+# Prefer single quotes for string with more double quotes
+"' \" \" '' \" \" '"
+
+# Prefer double quotes for string with more single quotes
+'\' " " \'\' " " \''
+
+# Prefer double quotes for string with equal amount of single and double quotes
+'" \' " " \'\''
+"' \" '' \" \" '"
+
+"\\' \"\""
+'\\\' ""'
+
+
+u"Test"
+U"Test"
+
+r"Test"
+R"Test"
+
+'This string will not include \
+backslashes or newline characters.'
+
+if True:
+    'This string will not include \
+        backslashes or newline characters.'
+
+"""Multiline
+String \"
+"""
+
+'''Multiline
+String \'
+'''

crates/ruff_python_formatter/src/expression/expr_constant.rs

@@ -2,15 +2,11 @@ use crate::comments::Comments;
 use crate::expression::parentheses::{
     default_expression_needs_parentheses, NeedsParentheses, Parentheses, Parenthesize,
 };
+use crate::expression::string::FormatString;
 use crate::prelude::*;
-use crate::trivia::SimpleTokenizer;
 use crate::{not_yet_implemented_custom_text, verbatim_text, FormatNodeRule};
-use ruff_formatter::{write, FormatContext, FormatError};
-use ruff_python_ast::str::{is_implicit_concatenation, leading_quote};
-use ruff_text_size::TextRange;
-use rustpython_parser::ast::{Constant, ExprConstant, Ranged};
-use rustpython_parser::lexer::{lex_starts_at, Lexer};
-use rustpython_parser::{Mode, Tok};
+use ruff_formatter::write;
+use rustpython_parser::ast::{Constant, ExprConstant};
 
 #[derive(Default)]
 pub struct FormatExprConstant;
@@ -33,7 +29,7 @@ impl FormatNodeRule<ExprConstant> for FormatExprConstant {
             Constant::Int(_) | Constant::Float(_) | Constant::Complex { .. } => {
                 write!(f, [verbatim_text(item)])
             }
-            Constant::Str(_) => FormatString { constant: item }.fmt(f),
+            Constant::Str(_) => FormatString::new(item).fmt(f),
             Constant::Bytes(_) => {
                 not_yet_implemented_custom_text(r#"b"NOT_YET_IMPLEMENTED_BYTE_STRING""#).fmt(f)
             }
@@ -73,22 +69,3 @@ impl NeedsParentheses for ExprConstant {
         }
     }
 }
-
-struct FormatString<'a> {
-    constant: &'a ExprConstant,
-}
-
-impl Format<PyFormatContext<'_>> for FormatString<'_> {
-    fn fmt(&self, f: &mut Formatter<PyFormatContext<'_>>) -> FormatResult<()> {
-        let constant = self.constant;
-        debug_assert!(constant.value.is_str());
-
-        let string_content = f.context().locator().slice(constant.range());
-
-        if is_implicit_concatenation(string_content) {
-            not_yet_implemented_custom_text(r#""NOT_YET_IMPLEMENTED_STRING""#).fmt(f)
-        } else {
-            source_text_slice(constant.range(), ContainsNewlines::Detect).fmt(f)
-        }
-    }
-}

crates/ruff_python_formatter/src/expression/mod.rs

@@ -37,6 +37,7 @@ pub(crate) mod expr_unary_op;
 pub(crate) mod expr_yield;
 pub(crate) mod expr_yield_from;
 pub(crate) mod parentheses;
+mod string;
 
 #[derive(Default)]
 pub struct FormatExpr {