[Macros] Parse top-level macro expansion 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

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

Sources/_SwiftSyntaxMacros/MacroSystem.swift

@@ -127,22 +127,28 @@ 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? DeclarationMacro.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? DeclarationMacro.Type {
+            let expandedItemList = try macro.expansion(
+              of: declExpansion,
+              in: &context
+            )
+            newItems.append(
+              contentsOf: expandedItemList.map {
+                CodeBlockItemSyntax(item: .decl($0))
+              }
+            )
+          } 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(
@@ -183,14 +189,14 @@ class MacroApplication: SyntaxRewriter {
         let freestandingMacro = macro as? DeclarationMacro.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)
+            contentsOf: expandedList.map { decl in
+              return MemberDeclListItemSyntax(decl: decl)
             }
           )
         } catch {

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,18 @@ final class DeclarationTests: XCTestCase {
       }
       """
     )
+    AssertParse(
+      """
+      #expand
+      """,
+      substructure: Syntax(
+        SourceFileSyntax(
+          CodeBlockItemListSyntax {
+            MacroExpansionDeclSyntax(macro: "expand")
+          }
+        )
+      )
+    )
   }
 
   func testVariableDeclWithGetSetButNoBrace() {