Refactor the logic to parse the accessor modifier list

Author: tbkka

Sources/SwiftParser/Declarations.swift

@@ -1658,25 +1658,47 @@ extension Parser {
 
   struct AccessorIntroducer {
     var attributes: RawAttributeListSyntax
-    var modifiers: RawDeclModifierListSyntax
+    var modifiers: RawDeclModifierListSyntax?
     var kind: AccessorDeclSyntax.AccessorSpecifierOptions
     var unexpectedBeforeToken: RawUnexpectedNodesSyntax?
     var token: RawTokenSyntax
   }
 
+  mutating func parseAccessorModifierList(count: Int) -> RawDeclModifierListSyntax? {
+      if count == 0 { return nil }
+
+      var elements = [RawDeclModifierSyntax]()
+
+      for _ in 0..<count {
+          let (unexpectedBeforeName, name) = self.expect(anyIn: AccessorModifier.self, default: .mutating)
+          let modifier = RawDeclModifierSyntax(
+            unexpectedBeforeName,
+            name: name,
+            detail: nil,
+            arena: self.arena
+          )
+          elements.append(modifier)
+      }
+
+      return RawDeclModifierListSyntax(
+        elements: elements,
+        arena: self.arena
+      )
+  }
+
   mutating func parseAccessorIntroducer(
     forcedKind: (AccessorDeclSyntax.AccessorSpecifierOptions, TokenConsumptionHandle)? = nil
   ) -> AccessorIntroducer? {
     // Look ahead to verify attributes/modifiers/kind
     var look = self.lookahead()
     let _ = look.consumeAttributeList()
-    let _ = look.consume(anySequence: AccessorModifier.self)
+    let modifierCount = look.consume(anySequence: AccessorModifier.self)
     guard let (kind, _) = look.at(anyIn: AccessorDeclSyntax.AccessorSpecifierOptions.self) ?? forcedKind else {
       return nil
     }
 
     let attrs = self.parseAttributeList()
-    let modifiers = self.parseDeclModifierList()
+    let modifiers = self.parseAccessorModifierList(count: modifierCount)
 
     let (unexpectedBeforeIntroducer, introducer) = self.expect(kind.spec)
 

Sources/SwiftParser/Lookahead.swift

@@ -163,9 +163,12 @@ extension Parser.Lookahead {
 // MARK: Skipping a sequence of tokens
 
 extension Parser.Lookahead {
-    mutating func consume<SpecSet: TokenSpecSet>(anySequence: SpecSet.Type) {
+    mutating func consume<SpecSet: TokenSpecSet>(anySequence: SpecSet.Type) -> Int {
+        var count = 0
         while consume(ifAnyIn: SpecSet.self) != nil {
+            count += 1
         }
+        return count
     }
 }
 

Sources/SwiftParser/TokenSpecSet.swift

@@ -66,6 +66,7 @@ enum AccessorModifier: TokenSpecSet {
   case borrowing
   case mutating
   case nonmutating
+  case yielding
 
   init?(lexeme: Lexer.Lexeme, experimentalFeatures: Parser.ExperimentalFeatures) {
     switch PrepareForKeywordMatch(lexeme) {
@@ -74,6 +75,7 @@ enum AccessorModifier: TokenSpecSet {
     case TokenSpec(.borrowing): self = .borrowing
     case TokenSpec(.mutating): self = .mutating
     case TokenSpec(.nonmutating): self = .nonmutating
+    case TokenSpec(.yielding): self = .yielding
     default: return nil
     }
   }
@@ -85,6 +87,7 @@ enum AccessorModifier: TokenSpecSet {
     case .borrowing: return .keyword(.borrowing)
     case .mutating: return .keyword(.mutating)
     case .nonmutating: return .keyword(.nonmutating)
+    case .yielding: return .keyword(.yielding)
     }
   }
 }

Tests/SwiftParserTest/DeclarationTests.swift

@@ -3481,7 +3481,7 @@ final class DeclarationTests: ParserTestCase {
         }
       }
       """,
-      experimentalFeatures: .coroutineAccessors
+      experimentalFeatures: [.coroutineAccessors, .borrowAndMutateAccessors]
     )
     assertParse(
       """