fix additional semicolon during changine parentheses style in lazy_static macro

Author: Alexander Glusker

src/macros.rs

@@ -186,7 +186,7 @@ pub(crate) fn rewrite_macro(
 }
 
 //We return not only string but also new delimiter if it changes
-//It needs to remove semicolon if delimiter changes
+//It needs to remove semicolon if delimiter changes in some situations
 fn rewrite_macro_inner(
     mac: &ast::MacCall,
     extra_ident: Option<symbol::Ident>,
@@ -233,14 +233,7 @@ fn rewrite_macro_inner(
     // Format well-known macros which cannot be parsed as a valid AST.
     if macro_name == "lazy_static!" && !has_comment {
         if let success @ Some(..) = format_lazy_static(context, shape, ts.clone()) {
-            return (
-                success,
-                if original_style != Delimiter::Brace {
-                    Some(Delimiter::Brace)
-                } else {
-                    None
-                },
-            );
+            return (success, Some(Delimiter::Brace));
         }
     }
 
@@ -271,90 +264,84 @@ fn rewrite_macro_inner(
         return (rewrite, Some(style));
     }
 
-    (
-        match style {
-            Delimiter::Parenthesis => {
-                // Handle special case: `vec!(expr; expr)`
-                if vec_with_semi {
-                    handle_vec_semi(context, shape, arg_vec, macro_name, style)
-                } else {
-                    // Format macro invocation as function call, preserve the trailing
-                    // comma because not all macros support them.
-                    overflow::rewrite_with_parens(
-                        context,
-                        &macro_name,
-                        arg_vec.iter(),
-                        shape,
-                        mac.span(),
-                        context.config.fn_call_width(),
-                        if trailing_comma {
-                            Some(SeparatorTactic::Always)
-                        } else {
-                            Some(SeparatorTactic::Never)
-                        },
-                    )
-                    .map(|rw| match position {
-                        MacroPosition::Item => format!("{};", rw),
-                        _ => rw,
-                    })
-                }
-            }
-            Delimiter::Bracket => {
-                // Handle special case: `vec![expr; expr]`
-                if vec_with_semi {
-                    handle_vec_semi(context, shape, arg_vec, macro_name, style)
-                } else {
-                    // If we are rewriting `vec!` macro or other special macros,
-                    // then we can rewrite this as a usual array literal.
-                    // Otherwise, we must preserve the original existence of trailing comma.
-                    let mut force_trailing_comma = if trailing_comma {
+    let rewrite = match style {
+        Delimiter::Parenthesis => {
+            // Handle special case: `vec!(expr; expr)`
+            if vec_with_semi {
+                handle_vec_semi(context, shape, arg_vec, macro_name, style)
+            } else {
+                // Format macro invocation as function call, preserve the trailing
+                // comma because not all macros support them.
+                overflow::rewrite_with_parens(
+                    context,
+                    &macro_name,
+                    arg_vec.iter(),
+                    shape,
+                    mac.span(),
+                    context.config.fn_call_width(),
+                    if trailing_comma {
                         Some(SeparatorTactic::Always)
                     } else {
                         Some(SeparatorTactic::Never)
+                    },
+                )
+                .map(|rw| match position {
+                    MacroPosition::Item => format!("{};", rw),
+                    _ => rw,
+                })
+            }
+        }
+        Delimiter::Bracket => {
+            // Handle special case: `vec![expr; expr]`
+            if vec_with_semi {
+                handle_vec_semi(context, shape, arg_vec, macro_name, style)
+            } else {
+                // If we are rewriting `vec!` macro or other special macros,
+                // then we can rewrite this as a usual array literal.
+                // Otherwise, we must preserve the original existence of trailing comma.
+                let mut force_trailing_comma = if trailing_comma {
+                    Some(SeparatorTactic::Always)
+                } else {
+                    Some(SeparatorTactic::Never)
+                };
+                if is_forced_bracket && !is_nested_macro {
+                    context.leave_macro();
+                    if context.use_block_indent() {
+                        force_trailing_comma = Some(SeparatorTactic::Vertical);
                     };
-                    if is_forced_bracket && !is_nested_macro {
-                        context.leave_macro();
-                        if context.use_block_indent() {
-                            force_trailing_comma = Some(SeparatorTactic::Vertical);
-                        };
-                    }
-                    rewrite_array(
-                        &macro_name,
-                        arg_vec.iter(),
-                        mac.span(),
-                        context,
-                        shape,
-                        force_trailing_comma,
-                        Some(original_style),
-                    )
-                    .map(|rewrite| {
-                        let comma = match position {
-                            MacroPosition::Item => ";",
-                            _ => "",
-                        };
-
-                        format!("{rewrite}{comma}")
-                    })
                 }
+                let Some(rewrite) = rewrite_array(
+                    &macro_name,
+                    arg_vec.iter(),
+                    mac.span(),
+                    context,
+                    shape,
+                    force_trailing_comma,
+                    Some(original_style),
+                ) else {
+                    return (None, None);
+                };
+
+                let comma = match position {
+                    MacroPosition::Item => ";",
+                    _ => "",
+                };
+                Some(format!("{rewrite}{comma}"))
             }
-            Delimiter::Brace => {
-                // For macro invocations with braces, always put a space between
-                // the `macro_name!` and `{ /* macro_body */ }` but skip modifying
-                // anything in between the braces (for now).
-                let snippet = context.snippet(mac.span()).trim_start_matches(|c| c != '{');
-                match trim_left_preserve_layout(snippet, shape.indent, context.config) {
-                    Some(macro_body) => Some(format!("{macro_name} {macro_body}")),
-                    None => Some(format!("{macro_name} {snippet}")),
-                }
+        }
+        Delimiter::Brace => {
+            // For macro invocations with braces, always put a space between
+            // the `macro_name!` and `{ /* macro_body */ }` but skip modifying
+            // anything in between the braces (for now).
+            let snippet = context.snippet(mac.span()).trim_start_matches(|c| c != '{');
+            match trim_left_preserve_layout(snippet, shape.indent, context.config) {
+                Some(macro_body) => Some(format!("{macro_name} {macro_body}")),
+                None => Some(format!("{macro_name} {snippet}")),
             }
-            _ => unreachable!(),
-        },
-        if original_style != style {
-            Some(style)
-        } else {
-            None
-        },
-    )
+        }
+        _ => unreachable!(),
+    };
+    return (rewrite, Some(style));
 }
 
 fn handle_vec_semi(

src/visitor.rs

@@ -683,36 +683,37 @@ impl<'b, 'a: 'b> FmtVisitor<'a> {
 
         // 1 = ;
         let shape = self.shape().saturating_sub_width(1);
-        let (rewrite, new_delimiter) =
+        let original_style = macro_style(mac, &self.get_context());
+        let (rewrite, rewrite_style) =
             self.with_context(|ctx| rewrite_macro(mac, ident, ctx, shape, pos));
         // As of v638 of the rustc-ap-* crates, the associated span no longer includes
         // the trailing semicolon. This determines the correct span to ensure scenarios
         // with whitespace between the delimiters and trailing semi (i.e. `foo!(abc)     ;`)
         // are formatted correctly.
-        let (span, rewrite) = match macro_style(mac, &self.get_context()) {
-            Delimiter::Bracket | Delimiter::Parenthesis if MacroPosition::Item == pos => {
-                let search_span = mk_sp(mac.span().hi(), self.snippet_provider.end_pos());
-                let hi = self.snippet_provider.span_before(search_span, ";");
-                let target_span = mk_sp(mac.span().lo(), hi + BytePos(1));
-                let rewrite = rewrite.map(|rw| {
+        let rewrite = match rewrite_style.unwrap_or(original_style) {
+            Delimiter::Bracket | Delimiter::Parenthesis if MacroPosition::Item == pos => rewrite
+                .map(|rw| {
                     if !rw.ends_with(';') {
                         format!("{};", rw)
                     } else {
                         rw
                     }
-                });
-                (target_span, rewrite)
-            }
-            _ => (mac.span(), rewrite),
+                }),
+            _ => rewrite,
         };
 
-        //we need to ignore semicolon if it is after {} instead of ()
-        let span = if new_delimiter == Some(Delimiter::Brace) && MacroPosition::Statement == pos {
-            let search_span = mk_sp(mac.span().hi(), self.snippet_provider.end_pos());
-            let hi = self.snippet_provider.span_before(search_span, ";");
-            mk_sp(mac.span().lo(), hi + BytePos(1))
-        } else {
-            span
+        let span = match original_style {
+            Delimiter::Bracket | Delimiter::Parenthesis
+                if (MacroPosition::Item == pos)
+                    || (MacroPosition::Statement == pos)
+                        && rewrite_style
+                            .is_some_and(|x| x != original_style && x == Delimiter::Brace) =>
+            {
+                let search_span = mk_sp(mac.span().hi(), self.snippet_provider.end_pos());
+                let hi = self.snippet_provider.span_before(search_span, ";");
+                mk_sp(mac.span().lo(), hi + BytePos(1))
+            }
+            _ => mac.span(),
         };
         self.push_rewrite(span, rewrite);
     }