Make it possible to parse an accessor declaration on its own

Author: DougGregor

Sources/SwiftParser/Declarations.swift

@@ -1522,12 +1522,14 @@ extension Parser {
     var token: RawTokenSyntax
   }
 
-  mutating func parseAccessorIntroducer() -> AccessorIntroducer? {
+  mutating func parseAccessorIntroducer(
+    forcedKind: (AccessorKind, TokenConsumptionHandle)? = nil
+  ) -> AccessorIntroducer? {
     // Check there is an identifier before consuming
     var look = self.lookahead()
     let _ = look.consumeAttributeList()
     let hasModifier = look.consume(ifAny: [], contextualKeywords: ["mutating", "nonmutating", "__consuming"]) != nil
-    guard let (kind, handle) = look.at(anyIn: AccessorKind.self) else {
+    guard let (kind, handle) = look.at(anyIn: AccessorKind.self) ?? forcedKind else {
       return nil
     }
 
@@ -1590,15 +1592,17 @@ extension Parser {
     return specifiers
   }
 
-  /// Parse the body of a variable declaration. This can include explicit
-  /// getters, setters, and observers, or the body of a computed property.
+  /// Parse an accessor.
+  mutating func parseAccessorDecl() -> RawAccessorDeclSyntax {
+    let introducer = parseAccessorIntroducer(forcedKind: (.get, TokenConsumptionHandle(tokenKind: .contextualKeyword, missing: true)))!
+    return parseAccessorDecl(introducer: introducer)
+  }
+
+  /// Parse an accessor once we know we have an introducer
   ///
   /// Grammar
   /// =======
   ///
-  ///     getter-setter-block → code-block
-  ///     getter-setter-block → { getter-clause setter-clause opt }
-  ///     getter-setter-block → { setter-clause getter-clause }
   ///     getter-clause → attributes opt mutation-modifier opt get code-block
   ///     setter-clause → attributes opt mutation-modifier opt set setter-name opt code-block
   ///     setter-name → ( identifier )
@@ -1610,6 +1614,63 @@ extension Parser {
   ///     willSet-didSet-block → { didSet-clause willSet-clause opt }
   ///     willSet-clause → attributes opt willSet setter-name opt code-block
   ///     didSet-clause → attributes opt didSet setter-name opt code-block
+  private mutating func parseAccessorDecl(
+    introducer: AccessorIntroducer
+  ) -> RawAccessorDeclSyntax {
+    // 'set' and 'willSet' can have an optional name.  This isn't valid in a
+    // protocol, but we parse and then reject it for better QoI.
+    //
+    //     set-name    ::= '(' identifier ')'
+    let parameter: RawAccessorParameterSyntax?
+    if [AccessorKind.set, .willSet, .didSet].contains(introducer.kind), let lparen = self.consume(if: .leftParen) {
+      let (unexpectedBeforeName, name) = self.expectIdentifier()
+      let (unexpectedBeforeRParen, rparen) = self.expect(.rightParen)
+      parameter = RawAccessorParameterSyntax(
+        leftParen: lparen,
+        unexpectedBeforeName,
+        name: name,
+        unexpectedBeforeRParen,
+        rightParen: rparen,
+        arena: self.arena
+      )
+    } else {
+      parameter = nil
+    }
+
+    // Next, parse effects specifiers. While it's only valid to have them
+    // on 'get' accessors, we also emit diagnostics if they show up on others.
+    let asyncKeyword: RawTokenSyntax?
+    let throwsKeyword: RawTokenSyntax?
+    if self.at(anyIn: EffectsSpecifier.self) != nil {
+      asyncKeyword = self.parseEffectsSpecifier()
+      throwsKeyword = self.parseEffectsSpecifier()
+    } else {
+      asyncKeyword = nil
+      throwsKeyword = nil
+    }
+
+    let body = self.parseOptionalCodeBlock()
+    return RawAccessorDeclSyntax(
+      attributes: introducer.attributes,
+      modifier: introducer.modifier,
+      accessorKind: introducer.token,
+      parameter: parameter,
+      asyncKeyword: asyncKeyword,
+      throwsKeyword: throwsKeyword,
+      body: body,
+      arena: self.arena
+    )
+  }
+
+  /// Parse the body of a variable declaration. This can include explicit
+  /// getters, setters, and observers, or the body of a computed property.
+  ///
+  /// Grammar
+  /// =======
+  ///
+  ///     getter-setter-block → code-block
+  ///     getter-setter-block → { getter-clause setter-clause opt }
+  ///     getter-setter-block → { setter-clause getter-clause }
   @_spi(RawSyntax)
   public mutating func parseGetSet() -> RawSubscriptDeclSyntax.Accessor {
     // Parse getter and setter.
@@ -1664,52 +1725,7 @@ extension Parser {
           )
         }
 
-        // 'set' and 'willSet' can have an optional name.  This isn't valid in a
-        // protocol, but we parse and then reject it for better QoI.
-        //
-        //     set-name    ::= '(' identifier ')'
-        let parameter: RawAccessorParameterSyntax?
-        if [AccessorKind.set, .willSet, .didSet].contains(introducer.kind), let lparen = self.consume(if: .leftParen) {
-          let (unexpectedBeforeName, name) = self.expectIdentifier()
-          let (unexpectedBeforeRParen, rparen) = self.expect(.rightParen)
-          parameter = RawAccessorParameterSyntax(
-            leftParen: lparen,
-            unexpectedBeforeName,
-            name: name,
-            unexpectedBeforeRParen,
-            rightParen: rparen,
-            arena: self.arena
-          )
-        } else {
-          parameter = nil
-        }
-
-        // Next, parse effects specifiers. While it's only valid to have them
-        // on 'get' accessors, we also emit diagnostics if they show up on others.
-        let asyncKeyword: RawTokenSyntax?
-        let throwsKeyword: RawTokenSyntax?
-        if self.at(anyIn: EffectsSpecifier.self) != nil {
-          asyncKeyword = self.parseEffectsSpecifier()
-          throwsKeyword = self.parseEffectsSpecifier()
-        } else {
-          asyncKeyword = nil
-          throwsKeyword = nil
-        }
-
-        let body = self.parseOptionalCodeBlock()
-
-        elements.append(
-          RawAccessorDeclSyntax(
-            attributes: introducer.attributes,
-            modifier: introducer.modifier,
-            accessorKind: introducer.token,
-            parameter: parameter,
-            asyncKeyword: asyncKeyword,
-            throwsKeyword: throwsKeyword,
-            body: body,
-            arena: self.arena
-          )
-        )
+        elements.append(parseAccessorDecl(introducer: introducer))
       }
     }
 

Sources/_SwiftSyntaxMacros/PeerDeclarationMacro.swift

@@ -15,7 +15,7 @@ public protocol PeerDeclarationMacro: DeclarationMacro {
   /// particular expansion context.
   ///
   /// The macro expansion can introduce "peer" declarations that sit alongside
-  /// the
+  /// the given declaration.
   static func expansion(
     of node: CustomAttributeSyntax,
     attachedTo declaration: DeclSyntax,

gyb_syntax_support/DeclNodes.py

@@ -556,6 +556,7 @@
 
     Node('AccessorDecl', name_for_diagnostics='accessor', kind='Decl',
          traits=['Attributed'],
+         parser_function='parseAccessorDecl',
          children=[
              Child('Attributes', kind='AttributeList', name_for_diagnostics='attributes',
                    collection_element_name='Attribute', is_optional=True),