Parse macro declarations

Author: DougGregor

Sources/SwiftParser/Declarations.swift

@@ -102,6 +102,9 @@ extension TokenConsumer {
       return false
     case .initKeyword:
       return allowInitDecl
+    case .macroContextualKeyword:
+      // macro Foo ...
+      return subparser.peek().tokenKind == .identifier
     case .some(_):
       // All other decl start keywords unconditonally start a decl.
       return true
@@ -149,6 +152,7 @@ extension Parser {
   ///     declaration → subscript-declaration
   ///     declaration → operator-declaration
   ///     declaration → precedence-group-declaration
+  ///     declaration → macro-declaration
   ///
   ///     declarations → declaration declarations?
   ///
@@ -236,6 +240,8 @@ extension Parser {
       return RawDeclSyntax(self.parsePrecedenceGroupDeclaration(attrs, handle))
     case (.actorContextualKeyword, let handle)?:
       return RawDeclSyntax(self.parseNominalTypeDeclaration(for: RawActorDeclSyntax.self, attrs: attrs, introucerHandle: handle))
+    case (.macroContextualKeyword, let handle)?:
+      return RawDeclSyntax(self.parseMacroDeclaration(attrs: attrs, introducerHandle: handle))
     case nil:
       if inMemberDeclList {
         let isProbablyVarDecl = self.at(any: [.identifier, .wildcardKeyword]) && self.peek().tokenKind.is(any: [.colon, .equal, .comma])
@@ -2007,6 +2013,65 @@ extension Parser {
     }
   }
 
+  /// Parse a macro declaration.
+  mutating func parseMacroDeclaration(
+    attrs: DeclAttributes,
+    introducerHandle: RecoveryConsumptionHandle
+  ) -> RawMacroDeclSyntax {
+    let (unexpectedBeforeIntroducerKeyword, introducerKeyword) = self.eat(introducerHandle)
+    let (unexpectedBeforeName, name) = self.expectIdentifier(keywordRecovery: true)
+
+    // Optional generic parameters.
+    let genericParams: RawGenericParameterClauseSyntax?
+    if self.currentToken.starts(with: "<") {
+      genericParams = self.parseGenericParameters()
+    } else {
+      genericParams = nil
+    }
+
+    // Macro signature, which is either value-like or function-like.
+    let signature: RawMacroDeclSyntax.Signature
+    if let colon = self.consume(if: .colon) {
+      let type = self.parseType()
+      signature = .valueLike(
+        RawTypeAnnotationSyntax(colon: colon, type: type, arena: self.arena))
+    } else {
+      signature = .functionLike(self.parseFunctionSignature())
+    }
+
+    // External macro name
+    let (unexpectedBeforeEqual, equal) = self.expect(.equal)
+    let (unexpectedBeforeModuleName, moduleName) = self.expectIdentifier()
+    let (unexpectedBeforePeriod, period) = self.expect(.period)
+    let (unexpectedBeforeMacroTypeName, macroTypeName) = self.expectIdentifier()
+
+    let externalMacroName = RawExternalMacroNameSyntax(
+      unexpectedBeforeModuleName, moduleName: moduleName,
+      unexpectedBeforePeriod, period: period,
+      unexpectedBeforeMacroTypeName, macroTypeName: macroTypeName,
+      arena: self.arena
+    )
+
+    // Parse a 'where' clause if present.
+    let whereClause: RawGenericWhereClauseSyntax?
+    if self.at(.whereKeyword) {
+      whereClause = self.parseGenericWhereClause()
+    } else {
+      whereClause = nil
+    }
+
+    return RawMacroDeclSyntax(
+      attributes: attrs.attributes, modifiers: attrs.modifiers,
+      unexpectedBeforeIntroducerKeyword, macroKeyword: introducerKeyword,
+      unexpectedBeforeName, identifier: name,
+      genericParameterClause: genericParams,
+      signature: signature, unexpectedBeforeEqual, equal: equal,
+      externalName: externalMacroName,
+      genericWhereClause: whereClause,
+      arena: self.arena
+    )
+  }
+
   /// Parse a macro expansion as an declaration.
   ///
   ///

Sources/SwiftParser/RawTokenKindSubset.swift

@@ -322,6 +322,7 @@ enum DeclarationStart: RawTokenKindSubset {
   case importKeyword
   case initKeyword
   case letKeyword
+  case macroContextualKeyword
   case operatorKeyword
   case precedencegroupKeyword
   case protocolKeyword
@@ -333,6 +334,7 @@ enum DeclarationStart: RawTokenKindSubset {
   init?(lexeme: Lexer.Lexeme) {
     switch lexeme.tokenKind {
     case .identifier where lexeme.tokenText == "actor": self = .actorContextualKeyword
+    case .identifier where lexeme.tokenText == "macro": self = .macroContextualKeyword
     case .associatedtypeKeyword: self = .associatedtypeKeyword
     case .caseKeyword: self = .caseKeyword
     case .classKeyword: self = .classKeyword
@@ -367,6 +369,7 @@ enum DeclarationStart: RawTokenKindSubset {
     case .importKeyword: return .importKeyword
     case .initKeyword: return .initKeyword
     case .letKeyword: return .letKeyword
+    case .macroContextualKeyword: return .identifier
     case .operatorKeyword: return .operatorKeyword
     case .precedencegroupKeyword: return .precedencegroupKeyword
     case .protocolKeyword: return .protocolKeyword
@@ -380,6 +383,7 @@ enum DeclarationStart: RawTokenKindSubset {
   var contextualKeyword: SyntaxText? {
     switch self {
     case .actorContextualKeyword: return "actor"
+    case .macroContextualKeyword: return "macro"
     default: return nil
     }
   }
@@ -388,6 +392,7 @@ enum DeclarationStart: RawTokenKindSubset {
     switch self {
     case .actorContextualKeyword: return .declKeyword
     case .caseKeyword: return .declKeyword
+    case .macroContextualKeyword: return .declKeyword
     default: return nil
     }
   }

Tests/SwiftParserTest/DeclarationTests.swift

@@ -1322,6 +1322,25 @@ final class DeclarationTests: XCTestCase {
 
     AssertParse("func foo(body: (isolated String) -> Int) {}")
   }
+
+  func testMacroDecl() {
+    AssertParse("""
+      macro m1: Int = A.M1
+      macro m2(_: Int) = A.M2
+      macro m3(a b: Int) -> Int = A.M3
+      macro m4<T>: T = A.M4 where T.Assoc: P
+      macro m4<T: P>(_: T) = A.M4
+      """)
+
+    AssertParse("""
+      macro m1 1️⃣= A2️⃣
+      """,
+      diagnostics: [
+        DiagnosticSpec(locationMarker: "1️⃣", message: "expected parameter clause in function signature"),
+        DiagnosticSpec(locationMarker: "2️⃣", message: "expected '.' and macro type name in external macro name"),
+      ]
+    )
+  }
 }
 
 extension Parser.DeclAttributes {