[Parser] Attributes on MacroExpansionDeclSyntax

* Add `attributes` and `modifiers` to `MacroExpansionDeclSyntax`
* Diagnose whitespaces between # and the macro name
* Attach attributes to MacroExpansionDeclSyntax

rdar://107386648

Author: rintaro

CodeGeneration/Sources/SyntaxSupport/DeclNodes.swift

@@ -1278,6 +1278,18 @@ public let DECL_NODES: [Node] = [
       "FreestandingMacroExpansion"
     ],
     children: [
+      Child(
+        name: "Attributes",
+        kind: .collection(kind: "AttributeList", collectionElementName: "Attribute"),
+        nameForDiagnostics: "attributes",
+        isOptional: true
+      ),
+      Child(
+        name: "Modifiers",
+        kind: .collection(kind: "ModifierList", collectionElementName: "Modifier"),
+        nameForDiagnostics: "modifiers",
+        isOptional: true
+      ),
       Child(
         name: "PoundToken",
         kind: .token(choices: [.token(tokenKind: "PoundToken")]),

Sources/SwiftParser/Declarations.swift

@@ -29,18 +29,25 @@ extension DeclarationModifier {
 }
 
 extension TokenConsumer {
+  mutating func atStartOfFreestandingMacroExpansion() -> Bool {
+    if !self.at(.pound) {
+      return false
+    }
+    if self.peek().rawTokenKind != .identifier && !self.peek().isLexerClassifiedKeyword {
+      return false
+    }
+    if self.currentToken.trailingTriviaByteLength != 0 || self.peek().leadingTriviaByteLength != 0 {
+      return false
+    }
+    return true
+  }
+
   mutating func atStartOfDeclaration(
     isAtTopLevel: Bool = false,
     allowInitDecl: Bool = true,
     allowRecovery: Bool = false
   ) -> Bool {
     if self.at(anyIn: PoundDeclarationStart.self) != nil {
-      // Don't treat freestanding macro expansions as declarations. They'll be
-      // parsed as expressions.
-      if self.at(.pound) {
-        return false
-      }
-
       return true
     }
 
@@ -113,6 +120,16 @@ extension TokenConsumer {
     case .macroKeyword:
       // macro Foo ...
       return subparser.peek().rawTokenKind == .identifier
+    case .pound:
+      // Force parsing '#<identifier>' after attributes as a macro expansion decl.
+      if hasAttribute {
+        return true
+      }
+
+      // Otherwise, parse it as a expression.
+      // FIXME: C++ parser returns true if this is a top-level non-"script" files.
+      // But we don't have "is library" flag.
+      return false
     case .some(_):
       // All other decl start keywords unconditonally start a decl.
       return true
@@ -203,10 +220,6 @@ extension Parser {
         return .decls(RawMemberDeclListSyntax(elements: elements, arena: parser.arena))
       }
       return RawDeclSyntax(directive)
-    case (.pound, _)?:
-      // FIXME: If we can have attributes for macro expansions, handle this
-      // via DeclarationStart.
-      return RawDeclSyntax(self.parseMacroExpansionDeclaration())
     case nil:
       break
     }
@@ -258,6 +271,8 @@ extension Parser {
       return RawDeclSyntax(self.parseNominalTypeDeclaration(for: RawActorDeclSyntax.self, attrs: attrs, introucerHandle: handle))
     case (.macroKeyword, let handle)?:
       return RawDeclSyntax(self.parseMacroDeclaration(attrs: attrs, introducerHandle: handle))
+    case (.pound, let handle)?:
+      return RawDeclSyntax(self.parseMacroExpansionDeclaration(attrs, handle))
     case nil:
       if inMemberDeclList {
         let isProbablyVarDecl = self.at(.identifier, .wildcard) && self.peek().rawTokenKind.is(.colon, .equal, .comma)
@@ -2023,9 +2038,29 @@ extension Parser {
   /// =======
   ///
   /// macro-expansion-declaration → '#' identifier expr-call-suffix?
-  mutating func parseMacroExpansionDeclaration() -> RawMacroExpansionDeclSyntax {
-    let poundKeyword = self.consumeAnyToken()
-    let (unexpectedBeforeMacro, macro) = self.expectIdentifier()
+  mutating func parseMacroExpansionDeclaration(
+    _ attrs: DeclAttributes,
+    _ handle: RecoveryConsumptionHandle
+  ) -> RawMacroExpansionDeclSyntax {
+
+    let (unexpectedBeforePound, poundKeyword) = self.eat(handle)
+    // Don't allow space between '#' and the macro name.
+    if poundKeyword.trailingTriviaByteLength != 0 || self.currentToken.leadingTriviaByteLength != 0 {
+      return RawMacroExpansionDeclSyntax(
+        attributes: attrs.attributes,
+        modifiers: attrs.modifiers,
+        unexpectedBeforePound,
+        poundToken: poundKeyword,
+        macro: self.missingToken(.identifier),
+        genericArguments: nil,
+        leftParen: nil,
+        argumentList: .init(elements: [], arena: self.arena),
+        rightParen: nil, trailingClosure: nil,
+        additionalTrailingClosures: nil,
+        arena: self.arena
+      )
+    }
+    let (unexpectedBeforeMacro, macro) = self.expectIdentifier(keywordRecovery: true)
 
     // Parse the optional generic argument list.
     let generics: RawGenericArgumentClauseSyntax?
@@ -2063,6 +2098,9 @@ extension Parser {
     }
 
     return RawMacroExpansionDeclSyntax(
+      attributes: attrs.attributes,
+      modifiers: attrs.modifiers,
+      unexpectedBeforePound,
       poundToken: poundKeyword,
       unexpectedBeforeMacro,
       macro: macro,

Sources/SwiftParser/Expressions.swift

@@ -1394,8 +1394,21 @@ extension Parser {
     pattern: PatternContext,
     flavor: ExprFlavor
   ) -> RawMacroExpansionExprSyntax {
+    if !atStartOfFreestandingMacroExpansion() {
+      return RawMacroExpansionExprSyntax(
+        poundToken: self.consumeAnyToken(),
+        macro: self.missingToken(.identifier),
+        genericArguments: nil,
+        leftParen: nil,
+        argumentList: .init(elements: [], arena: self.arena),
+        rightParen: nil,
+        trailingClosure: nil,
+        additionalTrailingClosures: nil,
+        arena: self.arena
+      )
+    }
     let poundKeyword = self.consumeAnyToken()
-    let (unexpectedBeforeMacro, macro) = self.expectIdentifier()
+    let (unexpectedBeforeMacro, macro) = self.expectIdentifier(keywordRecovery: true)
 
     // Parse the optional generic argument list.
     let generics: RawGenericArgumentClauseSyntax?

Sources/SwiftParser/TokenSpecSet.swift

@@ -272,6 +272,7 @@ enum DeclarationStart: TokenSpecSet {
   case typealiasKeyword
   case varKeyword
   case inoutKeyword
+  case pound
 
   init?(lexeme: Lexer.Lexeme) {
     switch PrepareForKeywordMatch(lexeme) {
@@ -295,6 +296,7 @@ enum DeclarationStart: TokenSpecSet {
     case TokenSpec(.typealias): self = .typealiasKeyword
     case TokenSpec(.var): self = .varKeyword
     case TokenSpec(.inout): self = .inoutKeyword
+    case TokenSpec(.pound): self = .pound
     default: return nil
     }
   }
@@ -321,6 +323,7 @@ enum DeclarationStart: TokenSpecSet {
     case .typealiasKeyword: return .keyword(.typealias)
     case .varKeyword: return .keyword(.var)
     case .inoutKeyword: return TokenSpec(.inout, recoveryPrecedence: .declKeyword)
+    case .pound: return TokenSpec(.pound, recoveryPrecedence: .openingPoundIf)
     }
   }
 }
@@ -396,20 +399,17 @@ enum OperatorLike: TokenSpecSet {
 
 enum PoundDeclarationStart: TokenSpecSet {
   case poundIfKeyword
-  case pound
 
   init?(lexeme: Lexer.Lexeme) {
     switch lexeme.rawTokenKind {
     case .poundIfKeyword: self = .poundIfKeyword
-    case .pound: self = .pound
     default: return nil
     }
   }
 
   var spec: TokenSpec {
     switch self {
     case .poundIfKeyword: return .poundIfKeyword
-    case .pound: return .pound
     }
   }
 }

Sources/SwiftParserDiagnostics/generated/ChildNameForDiagnostics.swift

@@ -236,6 +236,10 @@ private func childNameForDiagnostics(_ keyPath: AnyKeyPath) -> String? {
     return "macro definition"
   case \MacroDeclSyntax.genericWhereClause:
     return "generic where clause"
+  case \MacroExpansionDeclSyntax.attributes:
+    return "attributes"
+  case \MacroExpansionDeclSyntax.modifiers:
+    return "modifiers"
   case \MemberAccessExprSyntax.base:
     return "base"
   case \MemberAccessExprSyntax.name:

Sources/SwiftSyntax/generated/ChildNameForKeyPath.swift

@@ -1995,8 +1995,16 @@ public func childName(_ keyPath: AnyKeyPath) -> String? {
     return "genericWhereClause"
   case \MacroDeclSyntax.unexpectedAfterGenericWhereClause:
     return "unexpectedAfterGenericWhereClause"
-  case \MacroExpansionDeclSyntax.unexpectedBeforePoundToken:
-    return "unexpectedBeforePoundToken"
+  case \MacroExpansionDeclSyntax.unexpectedBeforeAttributes:
+    return "unexpectedBeforeAttributes"
+  case \MacroExpansionDeclSyntax.attributes:
+    return "attributes"
+  case \MacroExpansionDeclSyntax.unexpectedBetweenAttributesAndModifiers:
+    return "unexpectedBetweenAttributesAndModifiers"
+  case \MacroExpansionDeclSyntax.modifiers:
+    return "modifiers"
+  case \MacroExpansionDeclSyntax.unexpectedBetweenModifiersAndPoundToken:
+    return "unexpectedBetweenModifiersAndPoundToken"
   case \MacroExpansionDeclSyntax.poundToken:
     return "poundToken"
   case \MacroExpansionDeclSyntax.unexpectedBetweenPoundTokenAndMacro:

Sources/SwiftSyntax/generated/raw/RawSyntaxNodes.swift

@@ -13322,7 +13322,11 @@ public struct RawMacroExpansionDeclSyntax: RawDeclSyntaxNodeProtocol {
   }
 
   public init(
-      _ unexpectedBeforePoundToken: RawUnexpectedNodesSyntax? = nil, 
+      _ unexpectedBeforeAttributes: RawUnexpectedNodesSyntax? = nil, 
+      attributes: RawAttributeListSyntax?, 
+      _ unexpectedBetweenAttributesAndModifiers: RawUnexpectedNodesSyntax? = nil, 
+      modifiers: RawModifierListSyntax?, 
+      _ unexpectedBetweenModifiersAndPoundToken: RawUnexpectedNodesSyntax? = nil, 
       poundToken: RawTokenSyntax, 
       _ unexpectedBetweenPoundTokenAndMacro: RawUnexpectedNodesSyntax? = nil, 
       macro: RawTokenSyntax, 
@@ -13342,95 +13346,115 @@ public struct RawMacroExpansionDeclSyntax: RawDeclSyntaxNodeProtocol {
       arena: __shared SyntaxArena
     ) {
     let raw = RawSyntax.makeLayout(
-      kind: .macroExpansionDecl, uninitializedCount: 17, arena: arena) { layout in
+      kind: .macroExpansionDecl, uninitializedCount: 21, arena: arena) { layout in
       layout.initialize(repeating: nil)
-      layout[0] = unexpectedBeforePoundToken?.raw
-      layout[1] = poundToken.raw
-      layout[2] = unexpectedBetweenPoundTokenAndMacro?.raw
-      layout[3] = macro.raw
-      layout[4] = unexpectedBetweenMacroAndGenericArguments?.raw
-      layout[5] = genericArguments?.raw
-      layout[6] = unexpectedBetweenGenericArgumentsAndLeftParen?.raw
-      layout[7] = leftParen?.raw
-      layout[8] = unexpectedBetweenLeftParenAndArgumentList?.raw
-      layout[9] = argumentList.raw
-      layout[10] = unexpectedBetweenArgumentListAndRightParen?.raw
-      layout[11] = rightParen?.raw
-      layout[12] = unexpectedBetweenRightParenAndTrailingClosure?.raw
-      layout[13] = trailingClosure?.raw
-      layout[14] = unexpectedBetweenTrailingClosureAndAdditionalTrailingClosures?.raw
-      layout[15] = additionalTrailingClosures?.raw
-      layout[16] = unexpectedAfterAdditionalTrailingClosures?.raw
+      layout[0] = unexpectedBeforeAttributes?.raw
+      layout[1] = attributes?.raw
+      layout[2] = unexpectedBetweenAttributesAndModifiers?.raw
+      layout[3] = modifiers?.raw
+      layout[4] = unexpectedBetweenModifiersAndPoundToken?.raw
+      layout[5] = poundToken.raw
+      layout[6] = unexpectedBetweenPoundTokenAndMacro?.raw
+      layout[7] = macro.raw
+      layout[8] = unexpectedBetweenMacroAndGenericArguments?.raw
+      layout[9] = genericArguments?.raw
+      layout[10] = unexpectedBetweenGenericArgumentsAndLeftParen?.raw
+      layout[11] = leftParen?.raw
+      layout[12] = unexpectedBetweenLeftParenAndArgumentList?.raw
+      layout[13] = argumentList.raw
+      layout[14] = unexpectedBetweenArgumentListAndRightParen?.raw
+      layout[15] = rightParen?.raw
+      layout[16] = unexpectedBetweenRightParenAndTrailingClosure?.raw
+      layout[17] = trailingClosure?.raw
+      layout[18] = unexpectedBetweenTrailingClosureAndAdditionalTrailingClosures?.raw
+      layout[19] = additionalTrailingClosures?.raw
+      layout[20] = unexpectedAfterAdditionalTrailingClosures?.raw
     }
     self.init(unchecked: raw)
   }
 
-  public var unexpectedBeforePoundToken: RawUnexpectedNodesSyntax? {
+  public var unexpectedBeforeAttributes: RawUnexpectedNodesSyntax? {
     layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 
+  public var attributes: RawAttributeListSyntax? {
+    layoutView.children[1].map(RawAttributeListSyntax.init(raw:))
+  }
+  
+  public var unexpectedBetweenAttributesAndModifiers: RawUnexpectedNodesSyntax? {
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
+  }
+  
+  public var modifiers: RawModifierListSyntax? {
+    layoutView.children[3].map(RawModifierListSyntax.init(raw:))
+  }
+  
+  public var unexpectedBetweenModifiersAndPoundToken: RawUnexpectedNodesSyntax? {
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
+  }
+  
   public var poundToken: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
+    layoutView.children[5].map(RawTokenSyntax.init(raw:))!
   }
 
   public var unexpectedBetweenPoundTokenAndMacro: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 
   public var macro: RawTokenSyntax {
-    layoutView.children[3].map(RawTokenSyntax.init(raw:))!
+    layoutView.children[7].map(RawTokenSyntax.init(raw:))!
   }
 
   public var unexpectedBetweenMacroAndGenericArguments: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
+    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 
   public var genericArguments: RawGenericArgumentClauseSyntax? {
-    layoutView.children[5].map(RawGenericArgumentClauseSyntax.init(raw:))
+    layoutView.children[9].map(RawGenericArgumentClauseSyntax.init(raw:))
   }
 
   public var unexpectedBetweenGenericArgumentsAndLeftParen: RawUnexpectedNodesSyntax? {
-    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
+    layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 
   public var leftParen: RawTokenSyntax? {
-    layoutView.children[7].map(RawTokenSyntax.init(raw:))
+    layoutView.children[11].map(RawTokenSyntax.init(raw:))
   }
 
   public var unexpectedBetweenLeftParenAndArgumentList: RawUnexpectedNodesSyntax? {
-    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:))
+    layoutView.children[12].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 
   public var argumentList: RawTupleExprElementListSyntax {
-    layoutView.children[9].map(RawTupleExprElementListSyntax.init(raw:))!
+    layoutView.children[13].map(RawTupleExprElementListSyntax.init(raw:))!
   }
 
   public var unexpectedBetweenArgumentListAndRightParen: RawUnexpectedNodesSyntax? {
-    layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw:))
+    layoutView.children[14].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 
   public var rightParen: RawTokenSyntax? {
-    layoutView.children[11].map(RawTokenSyntax.init(raw:))
+    layoutView.children[15].map(RawTokenSyntax.init(raw:))
   }
 
   public var unexpectedBetweenRightParenAndTrailingClosure: RawUnexpectedNodesSyntax? {
-    layoutView.children[12].map(RawUnexpectedNodesSyntax.init(raw:))
+    layoutView.children[16].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 
   public var trailingClosure: RawClosureExprSyntax? {
-    layoutView.children[13].map(RawClosureExprSyntax.init(raw:))
+    layoutView.children[17].map(RawClosureExprSyntax.init(raw:))
   }
 
   public var unexpectedBetweenTrailingClosureAndAdditionalTrailingClosures: RawUnexpectedNodesSyntax? {
-    layoutView.children[14].map(RawUnexpectedNodesSyntax.init(raw:))
+    layoutView.children[18].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 
   public var additionalTrailingClosures: RawMultipleTrailingClosureElementListSyntax? {
-    layoutView.children[15].map(RawMultipleTrailingClosureElementListSyntax.init(raw:))
+    layoutView.children[19].map(RawMultipleTrailingClosureElementListSyntax.init(raw:))
   }
 
   public var unexpectedAfterAdditionalTrailingClosures: RawUnexpectedNodesSyntax? {
-    layoutView.children[16].map(RawUnexpectedNodesSyntax.init(raw:))
+    layoutView.children[20].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }