From bf9f9f75c08a0ee629bd35d596b58f77ef9ed9ef Mon Sep 17 00:00:00 2001
From: broken-circle <252359939+broken-circle@users.noreply.github.com>
Date: Fri, 15 May 2026 21:23:06 -0700
Subject: [PATCH] Remove spurious leading newline in `AttributeRemover`

When the removed attribute's leading trivia contains the newline that
ends its line, the existing backward-trim drops the newline and the
trailing indentation. But when the attribute has no leading trivia of
its own (e.g. it's the first token of the file), the line-terminating
newline lives on the following node, out of reach of the backward-trim,
and is preserved as a spurious leading newline.

Detect that case and record that the next call to attach accumulated
trivia should also drop one leading newline from the combined result,
whether it ends up on the next kept attribute or the next token.
---
 .../MacroSystem.swift                         | 44 +++++++++++++++++--
 .../AttributeRemoverTests.swift               | 15 +++----
 2 files changed, 46 insertions(+), 13 deletions(-)

diff --git a/Sources/SwiftSyntaxMacroExpansion/MacroSystem.swift b/Sources/SwiftSyntaxMacroExpansion/MacroSystem.swift
index d3b356106c5..00c4369add1 100644
--- a/Sources/SwiftSyntaxMacroExpansion/MacroSystem.swift
+++ b/Sources/SwiftSyntaxMacroExpansion/MacroSystem.swift
@@ -527,6 +527,16 @@ public class AttributeRemover: SyntaxRewriter {
 
   var triviaToAttachToNextToken: Trivia = Trivia()
 
+  /// When `true`, the next call to `prependAndClearAccumulatedTrivia(to:)`
+  /// should also drop one leading newline (and any spaces/tabs that
+  /// immediately precede it) from the resulting trivia.
+  ///
+  /// This is set when we remove an attribute that occupies its own line but
+  /// whose own leading trivia does not contain the line-terminating newline
+  /// (e.g. the attribute is the first token of the file, so the newline
+  /// terminating its line lives on the following node).
+  var dropLeadingNewlineOnNextNode: Bool = false
+
   /// Initializes an attribute remover with a given predicate to determine which attributes to remove.
   ///
   /// - Parameter predicate: A closure that determines whether a given `AttributeSyntax` should be removed.
@@ -560,6 +570,16 @@ public class AttributeRemover: SyntaxRewriter {
           !nextToken.leadingTrivia.isEmpty
         {
           leadingTrivia = Trivia(pieces: leadingTrivia.pieces[..<lastNewline])
+        } else if leadingTrivia.isEmpty,
+          attribute.trailingTrivia.allSatisfy(\.isSpaceOrTab),
+          attribute.previousToken(viewMode: .sourceAccurate)
+            .map({ $0.trailingTrivia.pieces.last?.isNewline ?? false }) ?? true
+        {
+          // The attribute occupies its own line, but the newline terminating that
+          // line lives on a following node (either the next attribute or the next
+          // token on a following node) rather than on this attribute. Record that
+          // we need to drop that newline when we attach accumulated trivia.
+          dropLeadingNewlineOnNextNode = true
         }
 
         // Drop any spaces or tabs from the trailing trivia because there’s no
@@ -609,12 +629,30 @@ public class AttributeRemover: SyntaxRewriter {
   /// significant trivia accumulated from removed attributes to the provided subsequent node.
   /// Once attached, the accumulated trivia is cleared.
   ///
+  /// If `dropLeadingNewlineOnNextNode` is `true`, this function additionally
+  /// drops one leading newline (and any spaces or tabs that precede it) from
+  /// the combined trivia, removing the line vacated by a removed attribute
+  /// whose own leading trivia did not include that newline.
+  ///
   /// - Parameter node: The syntax node receiving the accumulated trivia.
   /// - Returns: The modified syntax node with the prepended trivia.
   private func prependAndClearAccumulatedTrivia<T: SyntaxProtocol>(to syntaxNode: T) -> T {
-    guard !triviaToAttachToNextToken.isEmpty else { return syntaxNode }
-    defer { triviaToAttachToNextToken = Trivia() }
-    return syntaxNode.with(\.leadingTrivia, triviaToAttachToNextToken + syntaxNode.leadingTrivia)
+    guard !triviaToAttachToNextToken.isEmpty || dropLeadingNewlineOnNextNode else {
+      return syntaxNode
+    }
+    defer {
+      triviaToAttachToNextToken = Trivia()
+      dropLeadingNewlineOnNextNode = false
+    }
+
+    var combined = triviaToAttachToNextToken + syntaxNode.leadingTrivia
+    if dropLeadingNewlineOnNextNode,
+      let firstNewline = combined.pieces.firstIndex(where: \.isNewline),
+      combined.pieces[..<firstNewline].allSatisfy(\.isSpaceOrTab)
+    {
+      combined = Trivia(pieces: combined.pieces[combined.index(after: firstNewline)...])
+    }
+    return syntaxNode.with(\.leadingTrivia, combined)
   }
 }
 
diff --git a/Tests/SwiftSyntaxMacroExpansionTest/AttributeRemoverTests.swift b/Tests/SwiftSyntaxMacroExpansionTest/AttributeRemoverTests.swift
index a3ab09c2d18..fe70cae6fb2 100644
--- a/Tests/SwiftSyntaxMacroExpansionTest/AttributeRemoverTests.swift
+++ b/Tests/SwiftSyntaxMacroExpansionTest/AttributeRemoverTests.swift
@@ -59,25 +59,23 @@ final class AttributeRemoverTests: XCTestCase {
     )
   }
 
-  // FIXME: `AttributeRemover` should not leave a leading newline.
   func testEmptyOnOwnLineBeforeVariable() {
     assertSyntaxRemovingTestAttributes(
       """
       @Test
       var x: Int
       """,
-      reduction: "\nvar x: Int"
+      reduction: "var x: Int"
     )
   }
 
-  // FIXME: `AttributeRemover` should not leave a leading newline.
   func testEmptyTwiceOnOwnLineBeforeVariable() {
     assertSyntaxRemovingTestAttributes(
       """
       @Test @Test
       var x: Int
       """,
-      reduction: "\nvar x: Int"
+      reduction: "var x: Int"
     )
   }
 
@@ -166,7 +164,6 @@ final class AttributeRemoverTests: XCTestCase {
     )
   }
 
-  // FIXME: `AttributeRemover` should not leave a leading newline.
   func testEmptyNewlineBlockComment() {
     assertSyntaxRemovingTestAttributes(
       """
@@ -175,7 +172,7 @@ final class AttributeRemoverTests: XCTestCase {
       var value: Int
       """,
       reduction: """
-        \n/* comment */
+        /* comment */
         var value: Int
         """
     )
@@ -339,7 +336,6 @@ final class AttributeRemoverTests: XCTestCase {
     )
   }
 
-  // FIXME: `AttributeRemover` should not leave a leading newline.
   func testEmptyAndAttributeOnOwnLinesBeforeVariable() {
     assertSyntaxRemovingTestAttributes(
       """
@@ -348,7 +344,7 @@ final class AttributeRemoverTests: XCTestCase {
       var x: Int
       """,
       reduction: """
-        \n@State
+        @State
         var x: Int
         """
     )
@@ -367,14 +363,13 @@ final class AttributeRemoverTests: XCTestCase {
     )
   }
 
-  // FIXME: `AttributeRemover` should not leave a leading newline.
   func testEmptyOnOwnLineThenEmptyBeforeVariable() {
     assertSyntaxRemovingTestAttributes(
       """
       @Test
       @Test var x: Int
       """,
-      reduction: "\nvar x: Int"
+      reduction: "var x: Int"
     )
   }