Use BestFitParenthesize layout for literals and match as

crates/ruff_python_formatter/resources/test/fixtures/ruff/pattern/pattern_maybe_parenthesize.py

@@ -0,0 +1,101 @@
+# Patterns that use BestFit should be parenthesized if they exceed the configured line width
+# but fit within parentheses.
+match x:
+ case (
+ "averyLongStringThatGetsParenthesizedOnceItExceedsTheConfiguredLineWidthFitsPar"
+ ):
+ pass
+
+
+match x:
+ case (
+ b"averyLongStringThatGetsParenthesizedOnceItExceedsTheConfiguredLineWidthFitsPa"
+ ):
+ pass
+
+match x:
+ case (
+ f"averyLongStringThatGetsParenthesizedOnceItExceedsTheConfiguredLineWidthFitsPa"
+ ):
+ pass
+
+
+match x:
+ case (
+ 5444444444444444444444444444444444444444444444444444444444444444444444444444444j
+ ):
+ pass
+
+
+match x:
+ case (
+ 5444444444444444444444444444444444444444444444444444444444444444444444444444444
+ ):
+ pass
+
+
+match x:
+ case (
+ 5.44444444444444444444444444444444444444444444444444444444444444444444444444444
+ ):
+ pass
+
+
+match x:
+ case (
+ averyLongIdentThatGetsParenthesizedOnceItExceedsTheConfiguredLineWidthFitsParenth
+ ):
+ pass
+
+
+# But they aren't parenthesized when they exceed the line length even parenthesized
+match x:
+ case "averyLongStringThatGetsParenthesizedOnceItExceedsTheConfiguredLineWidthFitsParenthesized":
+ pass
+
+
+match x:
+ case b"averyLongStringThatGetsParenthesizedOnceItExceedsTheConfiguredLineWidthFitsParenthesized":
+ pass
+
+match x:
+ case f"averyLongStringThatGetsParenthesizedOnceItExceedsTheConfiguredLineWidthFitsParenthesized":
+ pass
+
+
+match x:
+ case 54444444444444444444444444444444444444444444444444444444444444444444444444444444444j:
+ pass
+
+
+match x:
+ case 5444444444444444444444444444444444444444444444444444444444444444444444444444444444:
+ pass
+
+
+match x:
+ case 5.444444444444444444444444444444444444444444444444444444444444444444444444444444444:
+ pass
+
+
+match x:
+ case averyLongIdentifierThatGetsParenthesizedOnceItExceedsTheConfiguredLineWidthFitsParenthesized:
+ pass
+
+
+# It uses the Multiline layout when there's an alias.
+match x:
+ case (
+ averyLongIdentifierThatGetsParenthesizedOnceItExceedsTheConfiguredLineWidthFitsParenthe as b
+ ):
+ pass
+
+
+
+match x:
+ case (
+ "an implicit concatenated" "string literal" "in a match case" "that goes over multiple lines"
+ ):
+ pass
+
+

crates/ruff_python_formatter/src/other/match_case.rs

@@ -4,7 +4,9 @@ use ruff_python_ast::MatchCase;
 
 use crate::builders::parenthesize_if_expands;
 use crate::expression::parentheses::{NeedsParentheses, OptionalParentheses, Parentheses};
+use crate::pattern::maybe_parenthesize_pattern;
 use crate::prelude::*;
+use crate::preview::is_match_case_parentheses_enabled;
 use crate::statement::clause::{clause_body, clause_header, ClauseHeader};
 use crate::statement::suite::SuiteKind;
 
@@ -34,39 +36,40 @@ impl FormatNodeRule<MatchCase> for FormatMatchCase {
  let comments = f.context().comments().clone();
  let dangling_item_comments = comments.dangling(item);
 
+ let format_pattern = format_with(|f| {
+ if is_match_case_parentheses_enabled(f.context()) {
+ maybe_parenthesize_pattern(pattern, item).fmt(f)
+ } else {
+ let has_comments =
+ comments.has_leading(pattern) || comments.has_trailing_own_line(pattern);
+
+ if has_comments {
+ pattern.format().with_options(Parentheses::Always).fmt(f)
+ } else {
+ match pattern.needs_parentheses(item.as_any_node_ref(), f.context()) {
+ OptionalParentheses::Multiline => parenthesize_if_expands(
+ &pattern.format().with_options(Parentheses::Never),
+ )
+ .fmt(f),
+ OptionalParentheses::Always => {
+ pattern.format().with_options(Parentheses::Always).fmt(f)
+ }
+ OptionalParentheses::Never | OptionalParentheses::BestFit => {
+ pattern.format().with_options(Parentheses::Never).fmt(f)
+ }
+ }
+ }
+ }
+ });
+
  write!(
  f,
  [
  clause_header(
  ClauseHeader::MatchCase(item),
  dangling_item_comments,
  &format_with(|f| {
- write!(f, [token("case"), space()])?;
-
- let has_comments = comments.has_leading(pattern)
- || comments.has_trailing_own_line(pattern);
-
- if has_comments {
- pattern.format().with_options(Parentheses::Always).fmt(f)?;
- } else {
- match pattern.needs_parentheses(item.as_any_node_ref(), f.context()) {
- OptionalParentheses::Multiline => {
- parenthesize_if_expands(
- &pattern.format().with_options(Parentheses::Never),
- )
- .fmt(f)?;
- }
- OptionalParentheses::Always => {
- pattern.format().with_options(Parentheses::Always).fmt(f)?;
- }
- OptionalParentheses::Never => {
- pattern.format().with_options(Parentheses::Never).fmt(f)?;
- }
- OptionalParentheses::BestFit => {
- pattern.format().with_options(Parentheses::Never).fmt(f)?;
- }
- }
- }
+ write!(f, [token("case"), space(), format_pattern])?;
 
  if let Some(guard) = guard {
  write!(f, [space(), token("if"), space(), guard.format()])?;

crates/ruff_python_formatter/src/pattern/mod.rs

@@ -1,14 +1,16 @@
 use ruff_formatter::{FormatOwnedWithRule, FormatRefWithRule, FormatRule, FormatRuleWithOptions};
 use ruff_python_ast::AnyNodeRef;
-use ruff_python_ast::Pattern;
+use ruff_python_ast::{MatchCase, Pattern};
 use ruff_python_trivia::CommentRanges;
 use ruff_python_trivia::{
  first_non_trivia_token, BackwardsTokenizer, SimpleToken, SimpleTokenKind,
 };
 use ruff_text_size::Ranged;
 
+use crate::builders::parenthesize_if_expands;
+use crate::context::{NodeLevel, WithNodeLevel};
 use crate::expression::parentheses::{
- parenthesized, NeedsParentheses, OptionalParentheses, Parentheses,
+ optional_parentheses, parenthesized, NeedsParentheses, OptionalParentheses, Parentheses,
 };
 use crate::prelude::*;
 
@@ -150,3 +152,70 @@ impl NeedsParentheses for Pattern {
  }
  }
 }
+
+pub(crate) fn maybe_parenthesize_pattern<'a>(
+ pattern: &'a Pattern,
+ case: &'a MatchCase,
+) -> MaybeParenthesizePattern<'a> {
+ MaybeParenthesizePattern { pattern, case }
+}
+
+#[derive(Debug)]
+pub(crate) struct MaybeParenthesizePattern<'a> {
+ pattern: &'a Pattern,
+ case: &'a MatchCase,
+}
+
+impl Format<PyFormatContext<'_>> for MaybeParenthesizePattern<'_> {
+ fn fmt(&self, f: &mut Formatter<PyFormatContext<'_>>) -> FormatResult<()> {
+ let MaybeParenthesizePattern { pattern, case } = self;
+
+ let comments = f.context().comments();
+ let pattern_comments = comments.leading_dangling_trailing(*pattern);
+
+ // If the pattern has comments, we always want to preserve the parentheses. This also
+ // ensures that we correctly handle parenthesized comments, and don't need to worry about
+ // them in the implementation below.
+ if pattern_comments.has_leading() || pattern_comments.has_trailing_own_line() {
+ return pattern.format().with_options(Parentheses::Always).fmt(f);
+ }
+
+ let needs_parentheses = pattern.needs_parentheses(AnyNodeRef::from(*case), f.context());
+
+ match needs_parentheses {
+ OptionalParentheses::Always => {
+ pattern.format().with_options(Parentheses::Always).fmt(f)
+ }
+ OptionalParentheses::Never => pattern.format().with_options(Parentheses::Never).fmt(f),
+ OptionalParentheses::Multiline => {
+ if can_pattern_omit_optional_parentheses(pattern, f.context()) {
+ optional_parentheses(&pattern.format().with_options(Parentheses::Never)).fmt(f)
+ } else {
+ parenthesize_if_expands(&pattern.format().with_options(Parentheses::Never))
+ .fmt(f)
+ }
+ }
+ OptionalParentheses::BestFit => {
+ if pattern_comments.has_trailing() {
+ pattern.format().with_options(Parentheses::Always).fmt(f)
+ } else {
+ // The group id is necessary because the nested expressions may reference it.
+ let group_id = f.group_id("optional_parentheses");
+ let f = &mut WithNodeLevel::new(NodeLevel::Expression(Some(group_id)), f);
+
+ best_fit_parenthesize(&pattern.format().with_options(Parentheses::Never))
+ .with_group_id(Some(group_id))
+ .fmt(f)
+ }
+ }
+ }
+ }
+}
+
+pub(crate) fn can_pattern_omit_optional_parentheses(
+ _pattern: &Pattern,
+ _context: &PyFormatContext,
+) -> bool {
+ // TODO Implement
+ false
+}

crates/ruff_python_formatter/src/pattern/pattern_match_as.rs

@@ -5,6 +5,7 @@ use ruff_python_ast::PatternMatchAs;
 use crate::comments::dangling_comments;
 use crate::expression::parentheses::{NeedsParentheses, OptionalParentheses};
 use crate::prelude::*;
+use crate::preview::is_match_case_parentheses_enabled;
 
 #[derive(Default)]
 pub struct FormatPatternMatchAs;
@@ -54,8 +55,16 @@ impl NeedsParentheses for PatternMatchAs {
  fn needs_parentheses(
  &self,
  _parent: AnyNodeRef,
- _context: &PyFormatContext,
+ context: &PyFormatContext,
  ) -> OptionalParentheses {
- OptionalParentheses::Multiline
+ if is_match_case_parentheses_enabled(context) {
+ if self.name.is_some() {
+ OptionalParentheses::Multiline
+ } else {
+ OptionalParentheses::BestFit
+ }
+ } else {
+ OptionalParentheses::Multiline
+ }
  }
 }

crates/ruff_python_formatter/src/pattern/pattern_match_value.rs

@@ -3,6 +3,7 @@ use ruff_python_ast::PatternMatchValue;
 
 use crate::expression::parentheses::{NeedsParentheses, OptionalParentheses, Parentheses};
 use crate::prelude::*;
+use crate::preview::is_match_case_parentheses_enabled;
 
 #[derive(Default)]
 pub struct FormatPatternMatchValue;
@@ -17,9 +18,13 @@ impl FormatNodeRule<PatternMatchValue> for FormatPatternMatchValue {
 impl NeedsParentheses for PatternMatchValue {
  fn needs_parentheses(
  &self,
- _parent: AnyNodeRef,
- _context: &PyFormatContext,
+ parent: AnyNodeRef,
+ context: &PyFormatContext,
  ) -> OptionalParentheses {
- OptionalParentheses::Never
+ if is_match_case_parentheses_enabled(context) {
+ self.value.needs_parentheses(parent, context)
+ } else {
+ OptionalParentheses::Never
+ }
  }
 }

crates/ruff_python_formatter/src/preview.rs

@@ -36,3 +36,9 @@ pub(crate) fn is_empty_parameters_no_unnecessary_parentheses_around_return_value
 ) -> bool {
  context.is_preview()
 }
+
+/// See [#6933](https:/astral-sh/ruff/issues/6933).
+/// This style also covers the black preview styles `remove_redundant_guard_parens` and `parens_for_long_if_clauses_in_case_block `.
+pub(crate) fn is_match_case_parentheses_enabled(context: &PyFormatContext) -> bool {
+ context.is_preview()
+}