[Macros] Freestanding macros expand to CodeBlockItemList; parse top-level macro expansion decls

- Change the return type of `FreestandingDeclarationMacro.expanion(of:in:)` to ``CodeBlockItemListSyntax` to allow expressions, statements, and declarations.
- Parse freestanding macro expansions as declarations rather than expressions when it's not part of a statement or expression (i.e. "top-level").

Author: rxwei

Sources/SwiftParser/Declarations.swift

@@ -192,14 +192,12 @@ extension Parser {
       return RawDeclSyntax(directive)
     case (.poundWarningKeyword, _)?, (.poundErrorKeyword, _)?:
       return self.parsePoundDiagnosticDeclaration()
-    case nil:
-      break
-    }
-
-    if (self.at(.pound)) {
+    case (.pound, _)?:
       // FIXME: If we can have attributes for macro expansions, handle this
       // via DeclarationStart.
       return RawDeclSyntax(self.parseMacroExpansionDeclaration())
+    case nil:
+      break
     }
 
     let attrs = DeclAttributes(

Sources/SwiftParser/RawTokenKindSubset.swift

@@ -499,12 +499,14 @@ enum PoundDeclarationStart: RawTokenKindSubset {
   case poundIfKeyword
   case poundWarningKeyword
   case poundErrorKeyword
+  case pound
 
   init?(lexeme: Lexer.Lexeme) {
     switch lexeme.tokenKind {
     case .poundIfKeyword: self = .poundIfKeyword
     case .poundWarningKeyword: self = .poundWarningKeyword
     case .poundErrorKeyword: self = .poundErrorKeyword
+    case .pound: self = .pound
     default: return nil
     }
   }
@@ -514,6 +516,7 @@ enum PoundDeclarationStart: RawTokenKindSubset {
     case .poundIfKeyword: return .poundIfKeyword
     case .poundWarningKeyword: return .poundWarningKeyword
     case .poundErrorKeyword: return .poundErrorKeyword
+    case .pound: return .pound
     }
   }
 }

Sources/_SwiftSyntaxMacros/FreestandingDeclarationMacro.swift

@@ -17,5 +17,5 @@ public protocol FreestandingDeclarationMacro: DeclarationMacro {
   static func expansion(
     of node: MacroExpansionDeclSyntax,
     in context: inout MacroExpansionContext
-  ) throws -> [DeclSyntax]
+  ) throws -> CodeBlockItemListSyntax
 }

Sources/_SwiftSyntaxMacros/MacroSystem.swift

@@ -88,22 +88,22 @@ class MacroApplication: SyntaxRewriter {
     for item in node {
       // Expand declaration macros that were parsed as macro expansion
       // expressions in this context.
-      if case let .expr(exprItem) = item.item,
-        let exprExpansion = exprItem.as(MacroExpansionExprSyntax.self),
-        let macro = macroSystem.macros[exprExpansion.macro.text],
-        let freestandingMacro = macro as? FreestandingDeclarationMacro.Type
+      if case let .decl(declItem) = item.item,
+        let declExpansion = declItem.as(MacroExpansionDeclSyntax.self),
+        let macro = macroSystem.macros[declExpansion.macro.text]
       {
         do {
-          let expandedDecls = try freestandingMacro.expansion(
-            of: exprExpansion.asMacroExpansionDecl(),
-            in: &context
-          )
-
-          newItems.append(
-            contentsOf: expandedDecls.map { decl in
-              CodeBlockItemSyntax(item: .decl(decl))
-            }
-          )
+          if let macro = macro as? FreestandingDeclarationMacro.Type {
+            let expandedItemList = try macro.expansion(
+              of: declExpansion, in: &context
+            )
+            newItems.append(contentsOf: expandedItemList)
+          } else if let macro = macro as? ExpressionMacro.Type {
+            let expandedExpr = try macro.expansion(
+              of: declExpansion.asMacroExpansionExpr(), in: &context
+            )
+            newItems.append(CodeBlockItemSyntax(item: .init(expandedExpr)))
+          }
         } catch {
           // Record the error
           context.diagnose(
@@ -144,16 +144,22 @@ class MacroApplication: SyntaxRewriter {
         let freestandingMacro = macro as? FreestandingDeclarationMacro.Type
       {
         do {
-          let expandedDecls = try freestandingMacro.expansion(
+          let expandedList = try freestandingMacro.expansion(
             of: declExpansion,
             in: &context
           )
 
-          newItems.append(
-            contentsOf: expandedDecls.map { decl in
-              MemberDeclListItemSyntax(decl: decl)
-            }
-          )
+          newItems.append(contentsOf: expandedList.compactMap { item in
+            guard let decl = item.item.as(DeclSyntax.self) else { return nil }
+            return MemberDeclListItemSyntax(
+              leadingTrivia: item.leadingTrivia,
+              item.unexpectedBeforeItem,
+              decl: decl,
+              item.unexpectedBetweenItemAndSemicolon,
+              semicolon: item.semicolon,
+              item.unexpectedBetweenSemicolonAndErrorTokens,
+              trailingTrivia: item.trailingTrivia)
+          })
         } catch {
           // Record the error
           context.diagnose(

Sources/_SwiftSyntaxMacros/Syntax+MacroEvaluation.swift

@@ -24,11 +24,11 @@ struct ThrownErrorDiagnostic: DiagnosticMessage {
   }
 }
 
-extension MacroExpansionExprSyntax {
+extension MacroExpansionDeclSyntax {
   /// Macro expansion declarations are parsed in some positions where an
   /// expression is also warranted, so
-  func asMacroExpansionDecl() -> MacroExpansionDeclSyntax {
-    MacroExpansionDeclSyntax(
+  public func asMacroExpansionExpr() -> MacroExpansionExprSyntax {
+    MacroExpansionExprSyntax(
       unexpectedBeforePoundToken,
       poundToken: poundToken,
       unexpectedBetweenPoundTokenAndMacro,
@@ -47,7 +47,9 @@ extension MacroExpansionExprSyntax {
       unexpectedAfterAdditionalTrailingClosures
     )
   }
+}
 
+extension MacroExpansionExprSyntax {
   /// Evaluate the given macro for this syntax node, producing the expanded
   /// result and (possibly) some diagnostics.
   func evaluateMacro(

Tests/SwiftParserTest/DeclarationTests.swift

@@ -1162,6 +1162,13 @@ final class DeclarationTests: XCTestCase {
       }
       """
     )
+    AssertParse(
+      """
+      #expand
+      """,
+      substructure: Syntax(SourceFileSyntax(CodeBlockItemList {
+        MacroExpansionDecl(macro: "expand")
+      })))
   }
 
   func testVariableDeclWithGetSetButNoBrace() {

Tests/SwiftSyntaxMacrosTest/MacroSystemTests.swift

@@ -158,7 +158,7 @@ public struct ErrorMacro: FreestandingDeclarationMacro {
   public static func expansion(
     of node: MacroExpansionDeclSyntax,
     in context: inout MacroExpansionContext
-  ) throws -> [DeclSyntax] {
+  ) throws -> CodeBlockItemListSyntax {
     guard let firstElement = node.argumentList.first,
       let stringLiteral = firstElement.expression
         .as(StringLiteralExprSyntax.self),
@@ -187,7 +187,7 @@ struct DefineBitwidthNumberedStructsMacro: FreestandingDeclarationMacro {
   static func expansion(
     of node: MacroExpansionDeclSyntax,
     in context: inout MacroExpansionContext
-  ) throws -> [DeclSyntax] {
+  ) throws -> CodeBlockItemListSyntax {
     guard let firstElement = node.argumentList.first,
       let stringLiteral = firstElement.expression
         .as(StringLiteralExprSyntax.self),
@@ -199,12 +199,15 @@ struct DefineBitwidthNumberedStructsMacro: FreestandingDeclarationMacro {
       )
     }
 
-    return [8, 16, 32, 64].map { bitwidth in
+    let decls: [Decl] = [8, 16, 32, 64].map { bitwidth in
       """
 
       struct \(raw: prefix)\(raw: String(bitwidth)) { }
       """
     }
+    // TODO: Interpolate to `CodeBlockItemList` directly when it supports
+    // string interpolation.
+    return CodeBlockItemList(decls.map { CodeBlockItemSyntax(item: .init($0)) })
   }
 }