More preview gating

crates/ruff_python_formatter/src/expression/mod.rs

@@ -21,6 +21,7 @@ use crate::expression::parentheses::{
 use crate::prelude::*;
 use crate::preview::{
     is_empty_parameters_no_unnecessary_parentheses_around_return_value_enabled,
+    is_f_string_implicit_concatenated_string_literal_quotes_enabled,
     is_hug_parens_with_braces_and_square_brackets_enabled,
 };
 
@@ -768,18 +769,26 @@ impl<'input> CanOmitOptionalParenthesesVisitor<'input> {
             Expr::StringLiteral(ast::ExprStringLiteral { value, .. })
                 if value.is_implicit_concatenated() =>
             {
-                // FIXME make this a preview only change
-                // self.update_max_precedence(OperatorPrecedence::String);
+                if !is_f_string_implicit_concatenated_string_literal_quotes_enabled(self.context) {
+                    self.update_max_precedence(OperatorPrecedence::String);
+                }
+
                 return;
             }
             Expr::BytesLiteral(ast::ExprBytesLiteral { value, .. })
                 if value.is_implicit_concatenated() =>
             {
-                // self.update_max_precedence(OperatorPrecedence::String);
+                if !is_f_string_implicit_concatenated_string_literal_quotes_enabled(self.context) {
+                    self.update_max_precedence(OperatorPrecedence::String);
+                }
+
                 return;
             }
             Expr::FString(ast::ExprFString { value, .. }) if value.is_implicit_concatenated() => {
-                // self.update_max_precedence(OperatorPrecedence::String);
+                if !is_f_string_implicit_concatenated_string_literal_quotes_enabled(self.context) {
+                    self.update_max_precedence(OperatorPrecedence::String);
+                }
+
                 return;
             }
 
@@ -1257,9 +1266,8 @@ pub(crate) fn is_splittable_expression(expr: &Expr, context: &PyFormatContext) -
         }
 
         // String like literals can expand if they are implicit concatenated.
-        // TODO REVIEW
         Expr::FString(fstring) => fstring.value.is_implicit_concatenated(),
-        Expr::StringLiteral(_) => false,
+        Expr::StringLiteral(string) => string.value.is_implicit_concatenated(),
         Expr::BytesLiteral(bytes) => bytes.value.is_implicit_concatenated(),
 
         // Expressions that have no split points per se, but they contain nested sub expressions that might expand.

crates/ruff_python_formatter/src/pattern/mod.rs

@@ -14,6 +14,7 @@ use crate::expression::parentheses::{
     optional_parentheses, parenthesized, NeedsParentheses, OptionalParentheses, Parentheses,
 };
 use crate::prelude::*;
+use crate::preview::is_join_implicit_concatenated_string_enabled;
 
 pub(crate) mod pattern_arguments;
 pub(crate) mod pattern_keyword;
@@ -226,7 +227,7 @@ pub(crate) fn can_pattern_omit_optional_parentheses(
     pattern: &Pattern,
     context: &PyFormatContext,
 ) -> bool {
-    let mut visitor = CanOmitOptionalParenthesesVisitor::default();
+    let mut visitor = CanOmitOptionalParenthesesVisitor::new(context);
     visitor.visit_pattern(pattern, context);
 
     if !visitor.any_parenthesized_expressions {
@@ -271,16 +272,32 @@ pub(crate) fn can_pattern_omit_optional_parentheses(
     }
 }
 
-#[derive(Debug, Default)]
+#[derive(Debug)]
 struct CanOmitOptionalParenthesesVisitor<'input> {
     max_precedence: OperatorPrecedence,
     max_precedence_count: usize,
     any_parenthesized_expressions: bool,
+    join_implicit_concatenated_strings: bool,
     last: Option<&'input Pattern>,
     first: First<'input>,
 }
 
 impl<'a> CanOmitOptionalParenthesesVisitor<'a> {
+    fn new(context: &PyFormatContext) -> Self {
+        Self {
+            max_precedence: OperatorPrecedence::default(),
+            max_precedence_count: 0,
+            any_parenthesized_expressions: false,
+            // TODO: Derive default for `CanOmitOptionalParenthesesVisitor` when removing the `join_implicit_concatenated_strings`
+            //   preview style.
+            join_implicit_concatenated_strings: is_join_implicit_concatenated_string_enabled(
+                context,
+            ),
+            last: None,
+            first: First::default(),
+        }
+    }
+
     fn visit_pattern(&mut self, pattern: &'a Pattern, context: &PyFormatContext) {
         match pattern {
             Pattern::MatchSequence(_) | Pattern::MatchMapping(_) => {
@@ -289,22 +306,27 @@ impl<'a> CanOmitOptionalParenthesesVisitor<'a> {
 
             Pattern::MatchValue(value) => match &*value.value {
                 Expr::StringLiteral(string) => {
-                    // TODO update?
-
-                    // self.update_max_precedence(OperatorPrecedence::String, string.value.len());
+                    if !self.join_implicit_concatenated_strings {
+                        self.update_max_precedence(OperatorPrecedence::String, string.value.len());
+                    }
+                    return;
                 }
                 Expr::BytesLiteral(bytes) => {
-                    // TODO update?
-                    // self.update_max_precedence(OperatorPrecedence::String, bytes.value.len());
+                    if !self.join_implicit_concatenated_strings {
+                        self.update_max_precedence(OperatorPrecedence::String, bytes.value.len());
+                    }
+                    return;
                 }
                 // F-strings are allowed according to python's grammar but fail with a syntax error at runtime.
                 // That's why we need to support them for formatting.
                 Expr::FString(string) => {
-                    // TODO update?
-                    // self.update_max_precedence(
-                    //     OperatorPrecedence::String,
-                    //     string.value.as_slice().len(),
-                    // );
+                    if !self.join_implicit_concatenated_strings {
+                        self.update_max_precedence(
+                            OperatorPrecedence::String,
+                            string.value.as_slice().len(),
+                        );
+                    }
+                    return;
                 }
 
                 Expr::NumberLiteral(_) | Expr::Attribute(_) | Expr::UnaryOp(_) => {

crates/ruff_python_formatter/src/statement/stmt_assign.rs

@@ -20,6 +20,7 @@ use crate::expression::{
     maybe_parenthesize_expression,
 };
 use crate::other::string_literal::StringLiteralKind;
+use crate::preview::is_join_implicit_concatenated_string_enabled;
 use crate::statement::trailing_semicolon;
 use crate::string::StringLikeExtensions;
 use crate::{has_skip_comment, prelude::*};
@@ -286,10 +287,12 @@ impl Format<PyFormatContext<'_>> for FormatStatementsLastExpression<'_> {
         match self {
             FormatStatementsLastExpression::LeftToRight { value, statement } => {
                 let can_inline_comment = should_inline_comments(value, *statement, f.context());
-                let is_implicit_concatenated = StringLike::try_from(*value).is_ok_and(|string| {
-                    string.is_implicit_concatenated()
-                        && !string.is_implicit_and_cant_join(f.context())
-                });
+                let is_implicit_concatenated =
+                    is_join_implicit_concatenated_string_enabled(f.context())
+                        && StringLike::try_from(*value).is_ok_and(|string| {
+                            string.is_implicit_concatenated()
+                                && !string.is_implicit_and_cant_join(f.context())
+                        });
 
                 if !can_inline_comment && !is_implicit_concatenated {
                     return maybe_parenthesize_expression(

crates/ruff_python_formatter/src/string/mod.rs

@@ -20,9 +20,7 @@ use crate::expression::parentheses::in_parentheses_only_soft_line_break_or_space
 use crate::other::f_string::FormatFString;
 use crate::other::string_literal::StringLiteralKind;
 use crate::prelude::*;
-use crate::preview::{
-    is_f_string_formatting_enabled, is_join_implicit_concatenated_string_enabled,
-};
+use crate::preview::is_join_implicit_concatenated_string_enabled;
 use crate::string::normalize::QuoteMetadata;
 use crate::QuoteStyle;