Automatically format expanded macros

Rather than requiring macro implementations to add required whitespace
and indentation, basic format all macro expansions. Right now this uses
the default four space indentation, we can consider having that inferred
later. Macros can opt-out of automatic formatting by implementing
`formatMode` and setting it to `.disabled`.

Update `trimmed` and `trimmedDescription` to only trim whitespace
leading and trailing whitespace, rather than removing the trivia
entirely. This allows macros to add comments to their expansions.

Resolves rdar://107731047.

Author: bnbarham

Sources/SwiftCompilerPluginMessageHandling/CMakeLists.txt

@@ -16,6 +16,7 @@ add_swift_host_library(SwiftCompilerPluginMessageHandling
 
 target_link_libraries(SwiftCompilerPluginMessageHandling PUBLIC
   SwiftSyntax
+  SwiftBasicFormat
   SwiftDiagnostics
   SwiftParser
   SwiftSyntaxMacros

Sources/SwiftCompilerPluginMessageHandling/Macros.swift

@@ -10,6 +10,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+import SwiftBasicFormat
 import SwiftDiagnostics
 import SwiftSyntax
 import SwiftSyntaxMacros
@@ -49,21 +50,21 @@ extension CompilerPluginMessageHandler {
           try exprMacroDef.expansion(of: node, in: context)
         }
         let rewritten = try _openExistential(macroSyntax, do: _expand)
-        expandedSource = rewritten.description
+        expandedSource = rewritten.formattedExpansion(macroDefinition.formatMode)
 
       case let declMacroDef as DeclarationMacro.Type:
         func _expand<Node: FreestandingMacroExpansionSyntax>(node: Node) throws -> [DeclSyntax] {
           try declMacroDef.expansion(of: node, in: context)
         }
         let rewritten = try _openExistential(macroSyntax, do: _expand)
-        expandedSource = CodeBlockItemListSyntax(rewritten.map { CodeBlockItemSyntax(item: .decl($0)) }).description
+        expandedSource = CodeBlockItemListSyntax(rewritten.map { CodeBlockItemSyntax(item: .decl($0)) }).formattedExpansion(macroDefinition.formatMode)
 
       case let codeItemMacroDef as CodeItemMacro.Type:
         func _expand<Node: FreestandingMacroExpansionSyntax>(node: Node) throws -> [CodeBlockItemSyntax] {
           try codeItemMacroDef.expansion(of: node, in: context)
         }
         let rewritten = try _openExistential(macroSyntax, do: _expand)
-        expandedSource = CodeBlockItemListSyntax(rewritten).description
+        expandedSource = CodeBlockItemListSyntax(rewritten).formattedExpansion(macroDefinition.formatMode)
 
       default:
         throw MacroExpansionError.unmathedMacroRole
@@ -113,7 +114,7 @@ extension CompilerPluginMessageHandler {
           in: context
         )
         expandedSources = accessors.map {
-          $0.trimmedDescription
+          $0.formattedExpansion(macroDefinition.formatMode)
         }
 
       case (let attachedMacro as MemberAttributeMacro.Type, .memberAttribute):
@@ -145,7 +146,7 @@ extension CompilerPluginMessageHandler {
 
         // Form a buffer containing an attribute list to return to the caller.
         expandedSources = attributes.map {
-          $0.trimmedDescription
+          $0.formattedExpansion(macroDefinition.formatMode)
         }
 
       case (let attachedMacro as MemberMacro.Type, .member):
@@ -170,7 +171,7 @@ extension CompilerPluginMessageHandler {
         let members = try _openExistential(declGroup, do: expandMemberMacro)
 
         // Form a buffer of member declarations to return to the caller.
-        expandedSources = members.map { $0.trimmedDescription }
+        expandedSources = members.map { $0.formattedExpansion(macroDefinition.formatMode) }
 
       case (let attachedMacro as PeerMacro.Type, .peer):
         let peers = try attachedMacro.expansion(
@@ -181,7 +182,7 @@ extension CompilerPluginMessageHandler {
 
         // Form a buffer of peer declarations to return to the caller.
         expandedSources = peers.map {
-          $0.trimmedDescription
+          $0.formattedExpansion(macroDefinition.formatMode)
         }
 
       case (let attachedMacro as ConformanceMacro.Type, .conformance):
@@ -234,3 +235,17 @@ extension CompilerPluginMessageHandler {
     )
   }
 }
+
+fileprivate extension SyntaxProtocol {
+  /// Perform a format if required and then trim any leading/trailing
+  /// whitespace.
+  func formattedExpansion(_ mode: FormatMode) -> String {
+    let formatted: Syntax
+    if mode == .auto {
+      formatted = self.formatted()
+    } else {
+      formatted = Syntax(self)
+    }
+    return formatted.trimmedDescription
+  }
+}

Sources/SwiftSyntax/Syntax.swift

@@ -534,18 +534,24 @@ public extension SyntaxProtocol {
     data.raw.write(to: &target)
   }
 
-  /// A copy of this node without the leading trivia of the first token in the
-  /// node and the trailing trivia of the last token in the node.
+  /// A copy of this node with leading whitespace of the first token and
+  /// trailing whitespace of the last token removed.
   var trimmed: Self {
     // TODO: Should only need one new node here
-    return self.with(\.leadingTrivia, []).with(\.trailingTrivia, [])
+    return self.with(
+      \.leadingTrivia,
+      Trivia(pieces: leadingTrivia.pieces.drop(while: { $0.isWhitespace }))
+    ).with(
+      \.trailingTrivia,
+      Trivia(pieces: trailingTrivia.pieces.reversed().drop(while: { $0.isWhitespace }).reversed())
+    )
   }
 
-  /// The description of this node without the leading trivia of the first token
-  /// in the node and the trailing trivia of the last token in the node.
+  /// The description of this node with leading whitespace of the first token
+  /// and trailing whitespace of the last token removed.
   var trimmedDescription: String {
-    // TODO: We shouldn't need to create to copies just to get the description
-    // without trivia.
+    // TODO: We shouldn't need to create to copies just to get the trimmed
+    // description.
     return self.trimmed.description
   }
 }

Sources/SwiftSyntaxMacros/CMakeLists.txt

@@ -15,6 +15,7 @@ add_swift_host_library(SwiftSyntaxMacros
   MacroProtocols/ExpressionMacro.swift
   MacroProtocols/FreestandingMacro.swift
   MacroProtocols/Macro.swift
+  MacroProtocols/Macro+Format.swift
   MacroProtocols/MemberAttributeMacro.swift
   MacroProtocols/MemberMacro.swift
   MacroProtocols/PeerMacro.swift

Sources/SwiftSyntaxMacros/MacroProtocols/Macro+Format.swift

@@ -0,0 +1,31 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2023 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+/// Describes the mode to use to format the result of an expansion.
+public enum FormatMode {
+  /// Perform a basic format of the expansion. This is primarily for inserting
+  /// whitespace as required (eg. between two keywords), but also adds simple
+  /// newline and indentation.
+  case auto
+
+  /// Disable automatically formatting the expanded macro. Trivia must be
+  /// manually inserted where required (eg. adding spaces between keywords).
+  case disabled
+}
+
+public extension Macro {
+  /// How the resulting expansion should be formatted, `.auto` by default.
+  /// Use `.disabled` for the expansion to be used as is.
+  static var formatMode: FormatMode {
+    return .auto
+  }
+}