Format PatternMatchOr

crates/ruff_python_formatter/resources/test/fixtures/ruff/statement/match.py

@@ -467,3 +467,37 @@ def foo():
         # e
     ):
         pass
+
+
+match pattern_match_or:
+    case ( # leading 1
+          a # trailing 1
+          # own line 1
+          | # trailing 2
+          # own line 2
+          b # trailing 3
+          # own line 3
+          | # trailing 4
+          # own line 4
+          c # trailing 5
+            ):
+        ...
+
+    case (
+        (a)
+        | # trailing
+        ( b )
+    ):
+        ...
+
+    case (a|b|c):
+        ...
+
+    case foo | bar | aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaahhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh:
+        ...
+
+    case ( # end of line
+          a | b
+    # own line
+    ):
+        ...

crates/ruff_python_formatter/src/lib.rs

@@ -1,15 +1,13 @@
 use thiserror::Error;
 
-use ruff_formatter::format_element::tag;
 use ruff_formatter::prelude::*;
 use ruff_formatter::{format, FormatError, Formatted, PrintError, Printed, SourceCode};
-use ruff_python_ast::node::{AnyNodeRef, AstNode};
+use ruff_python_ast::node::AstNode;
 use ruff_python_ast::Mod;
 use ruff_python_index::{CommentRanges, CommentRangesBuilder};
 use ruff_python_parser::lexer::{lex, LexicalError};
 use ruff_python_parser::{parse_tokens, Mode, ParseError};
 use ruff_source_file::Locator;
-use ruff_text_size::TextLen;
 
 use crate::comments::{
     dangling_comments, leading_comments, trailing_comments, Comments, SourceComment,
@@ -178,45 +176,6 @@ pub fn pretty_comments(formatted: &Formatted<PyFormatContext>, source: &str) ->
     )
 }
 
-pub(crate) struct NotYetImplementedCustomText<'a> {
-    text: &'static str,
-    node: AnyNodeRef<'a>,
-}
-
-/// Formats a placeholder for nodes that have not yet been implemented
-pub(crate) fn not_yet_implemented_custom_text<'a, T>(
-    text: &'static str,
-    node: T,
-) -> NotYetImplementedCustomText<'a>
-where
-    T: Into<AnyNodeRef<'a>>,
-{
-    NotYetImplementedCustomText {
-        text,
-        node: node.into(),
-    }
-}
-
-impl Format<PyFormatContext<'_>> for NotYetImplementedCustomText<'_> {
-    fn fmt(&self, f: &mut PyFormatter) -> FormatResult<()> {
-        f.write_element(FormatElement::Tag(Tag::StartVerbatim(
-            tag::VerbatimKind::Verbatim {
-                length: self.text.text_len(),
-            },
-        )));
-
-        text(self.text).fmt(f)?;
-
-        f.write_element(FormatElement::Tag(Tag::EndVerbatim));
-
-        f.context()
-            .comments()
-            .mark_verbatim_node_comments_formatted(self.node);
-
-        Ok(())
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use std::path::Path;

crates/ruff_python_formatter/src/pattern/pattern_match_or.rs

@@ -2,22 +2,46 @@ use ruff_formatter::write;
 use ruff_python_ast::node::AnyNodeRef;
 use ruff_python_ast::PatternMatchOr;
 
-use crate::expression::parentheses::{NeedsParentheses, OptionalParentheses};
-use crate::not_yet_implemented_custom_text;
+use crate::comments::leading_comments;
+use crate::expression::parentheses::{
+    in_parentheses_only_soft_line_break_or_space, NeedsParentheses, OptionalParentheses,
+};
 use crate::prelude::*;
 
 #[derive(Default)]
 pub struct FormatPatternMatchOr;
 
 impl FormatNodeRule<PatternMatchOr> for FormatPatternMatchOr {
     fn fmt_fields(&self, item: &PatternMatchOr, f: &mut PyFormatter) -> FormatResult<()> {
-        write!(
-            f,
-            [not_yet_implemented_custom_text(
-                "NOT_YET_IMPLEMENTED_PatternMatchOf | (y)",
-                item
-            )]
-        )
+        let PatternMatchOr { range: _, patterns } = item;
+        let inner = format_with(|f: &mut PyFormatter| {
+            let mut patterns = patterns.iter();
+            let comments = f.context().comments().clone();
+
+            let Some(first) = patterns.next() else {
+                return Ok(());
+            };
+
+            first.format().fmt(f)?;
+
+            for pattern in patterns {
+                let leading_value_comments = comments.leading(pattern);
+                // Format the expressions leading comments **before** the operator
+                if leading_value_comments.is_empty() {
+                    write!(f, [in_parentheses_only_soft_line_break_or_space()])?;
+                } else {
+                    write!(
+                        f,
+                        [hard_line_break(), leading_comments(leading_value_comments)]
+                    )?;
+                }
+                write!(f, [text("|"), space(), pattern.format()])?;
+            }
+
+            Ok(())
+        });
+
+        inner.fmt(f)
     }
 }