Fix handling of attribute in enum

src/items.rs

@@ -3,6 +3,7 @@
 use std::borrow::Cow;
 use std::cmp::{max, min, Ordering};
 
+use itertools::Itertools;
 use regex::Regex;
 use rustc_ast::visit;
 use rustc_ast::{ast, ptr};
@@ -647,28 +648,107 @@ impl<'a> FmtVisitor<'a> {
         // If one of the variants use multiple lines, use multi-lined formatting for all variants.
         let is_multi_line_variant = |item: &ListItem| -> bool {
             let variant_str = item.inner_as_ref();
-            if self.config.style_edition() < StyleEdition::Edition2024 {
+            if self.config.style_edition() <= StyleEdition::Edition2021 {
                 // Fall back to previous naive implementation (#5662) because of
                 // rustfmt's stability guarantees
                 return variant_str.contains('\n');
             }
 
-            let mut first_line_is_read = false;
-            for line in variant_str.split('\n') {
-                if first_line_is_read {
-                    return false;
+            // First exclude all outer one-line doc comments
+            let mut lines = variant_str
+                .split('\n')
+                .filter(|line| !line.trim().starts_with("///"));
+
+            let mut variant_str = lines.join("\n");
+
+            // Then exclude all outer documentation blocks
+            // Exclude one block per loop iteration
+            loop {
+                let mut block_found = false;
+                let mut chars = variant_str.chars().enumerate();
+                'block: while let Some((i, c)) = chars.next() {
+                    if c != '/' {
+                        continue;
+                    }
+                    let block_start = i;
+                    if let Some((_, '*')) = chars.next() {
+                        if let Some((_, '*')) = chars.next() {
+                            while let Some((_, c)) = chars.next() {
+                                if c == '*' {
+                                    if let Some((i, '/')) = chars.next() {
+                                        // block was found and ends at the i-th position
+                                        // We remove it from variant_str
+                                        let mut s = variant_str[..block_start].trim().to_owned();
+                                        s.push_str(variant_str[(i + 1)..].trim());
+                                        variant_str = s;
+                                        block_found = true;
+                                        break 'block;
+                                    }
+                                }
+                            }
+                        }
+                    }
                 }
 
-                // skip rustdoc comments and macro attributes
-                let line = line.trim_start();
-                if line.starts_with("///") || line.starts_with("#") {
-                    continue;
-                } else {
-                    first_line_is_read = true;
+                if !block_found {
+                    break;
+                }
+            }
+
+            // Skip macro attributes in variant_str
+            // We skip one macro attribute per loop iteration
+            loop {
+                let mut macro_attribute_found = false;
+                let mut macro_attribute_start_i = 0;
+                let mut bracket_count = 0;
+                let mut chars = variant_str.chars().enumerate();
+                while let Some((i, c)) = chars.next() {
+                    match c {
+                        '#' => {
+                            if let Some((_, '[')) = chars.next() {
+                                macro_attribute_start_i = i;
+                                bracket_count += 1;
+                            }
+                        }
+                        '[' => bracket_count += 1,
+                        ']' => {
+                            bracket_count -= 1;
+                            if bracket_count == 0 {
+                                // Macro attribute was found and ends at the i-th position
+                                // We remove it from variant_str
+                                let mut s =
+                                    variant_str[..macro_attribute_start_i].trim().to_owned();
+                                s.push_str(variant_str[(i + 1)..].trim());
+                                variant_str = s;
+                                macro_attribute_found = true;
+                                break;
+                            }
+                        }
+                        '\'' => {
+                            // Handle char in attribute
+                            chars.next();
+                            chars.next();
+                        }
+                        '"' => {
+                            // Handle quoted strings within attribute
+                            while let Some((_, c)) = chars.next() {
+                                if c == '\\' {
+                                    chars.next(); // Skip escaped character
+                                } else if c == '"' {
+                                    break; // end of string
+                                }
+                            }
+                        }
+                        _ => {}
+                    }
+                }
+
+                if !macro_attribute_found {
+                    break;
                 }
             }
 
-            true
+            variant_str.contains('\n')
         };
         let has_multiline_variant = items.iter().any(is_multi_line_variant);
         let has_single_line_variant = items.iter().any(|item| !is_multi_line_variant(item));

tests/target/attribute-in-enum/horizontal-with-doc.rs

@@ -2,7 +2,8 @@
 enum MyType {
     A { field1: bool, field2: bool },
     B { field1: bool, field2: bool },
-    /// OMG a comment
+    /// One-line doc comment
     C { field1: bool, field2: bool },
+    /** Documentation block */
     D { field1: bool, field2: bool },
 }

tests/target/attribute-in-enum/vertical-macro-multi-line.rs

@@ -0,0 +1,44 @@
+// rustfmt-style_edition: 2024
+enum A {
+    B {
+        a: usize,
+        b: usize,
+        c: usize,
+        d: usize,
+    },
+
+    #[multiline_macro_attribute(
+        very_very_long_option1,
+        very_very_long_option2,
+        very_very_long_option3
+    )]
+    C {
+        a: usize,
+    },
+
+    #[attr_with_expression1(x = ']')]
+    D1 {
+        a: usize,
+    },
+
+    #[attr_with_expression2(x = vec![])]
+    D2 {
+        a: usize,
+    },
+
+    #[attr_with_expression3(x = "]")]
+    D3 {
+        a: usize,
+    },
+
+    #[attr_with_expression4(x = "\"]")]
+    D4 {
+        a: usize,
+    },
+
+    #[attr1]
+    #[attr2]
+    D5 {
+        a: usize,
+    },
+}