[SE-0474] Support yielding borrow and yielding mutate accessors

CodeGeneration/Sources/SyntaxSupport/DeclNodes.swift

@@ -89,6 +89,7 @@ public let DECL_NODES: [Node] = [
     traits: [
       "WithOptionalCodeBlock",
       "WithAttributes",
+      "WithModifiers",
     ],
     children: [
       Child(
@@ -97,10 +98,10 @@ public let DECL_NODES: [Node] = [
         nameForDiagnostics: "attributes"
       ),
       Child(
-        name: "modifier",
-        kind: .node(kind: .declModifier),
+        name: "modifiers",
+        kind: .collection(kind: .declModifierList, collectionElementName: "Modifier", defaultsToEmpty: true),
         nameForDiagnostics: "modifiers",
-        isOptional: true
+        documentation: "Modifiers like `mutating` or `yielding` that affect the accessor declaration."
       ),
       Child(
         name: "accessorSpecifier",
@@ -495,6 +496,7 @@ public let DECL_NODES: [Node] = [
           .keyword(.unowned),
           .keyword(.weak),
           .keyword(.sending),
+          .keyword(.yielding),
         ])
       ),
       Child(

CodeGeneration/Sources/SyntaxSupport/KeywordSpec.swift

@@ -279,6 +279,7 @@ public enum Keyword: CaseIterable {
   case willSet
   case wrt
   case yield
+  case yielding
 
   public var spec: KeywordSpec {
     switch self {
@@ -537,7 +538,7 @@ public enum Keyword: CaseIterable {
     case .module:
       return KeywordSpec("module")
     case .mutate:
-      return KeywordSpec("mutate", experimentalFeature: .borrowAndMutateAccessors)
+      return KeywordSpec("mutate")
     case .mutableAddressWithNativeOwner:
       return KeywordSpec("mutableAddressWithNativeOwner")
     case .mutableAddressWithOwner:
@@ -692,6 +693,8 @@ public enum Keyword: CaseIterable {
       return KeywordSpec("wrt")
     case .yield:
       return KeywordSpec("yield")
+    case .yielding:
+      return KeywordSpec("yielding")
     }
   }
 }

Sources/SwiftParser/CollectionNodes+Parsable.swift

@@ -67,7 +67,7 @@ extension AccessorDeclListSyntax: SyntaxParseable {
     } makeMissing: { remainingTokens, arena in
       return RawAccessorDeclSyntax(
         attributes: RawAttributeListSyntax(elements: [], arena: arena),
-        modifier: nil,
+        modifiers: RawDeclModifierListSyntax(elements: [], arena: arena),
         accessorSpecifier: RawTokenSyntax(missing: .keyword, text: "get", arena: arena),
         parameters: nil,
         effectSpecifiers: nil,

Sources/SwiftParser/Declarations.swift

@@ -1658,44 +1658,51 @@ extension Parser {
 
   struct AccessorIntroducer {
     var attributes: RawAttributeListSyntax
-    var modifier: RawDeclModifierSyntax?
+    var modifiers: RawDeclModifierListSyntax
     var kind: AccessorDeclSyntax.AccessorSpecifierOptions
     var unexpectedBeforeToken: RawUnexpectedNodesSyntax?
     var token: RawTokenSyntax
   }
 
+  mutating func parseAccessorModifierList(count: Int) -> RawDeclModifierListSyntax {
+    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? {
-    // Check there is an identifier before consuming
+    // Look ahead to verify attributes/modifiers/kind
     var look = self.lookahead()
     let _ = look.consumeAttributeList()
-    let hasModifier = look.consume(ifAnyIn: AccessorModifier.self) != nil
+    let modifierCount = look.consume(anySequence: AccessorModifier.self)
     guard let (kind, _) = look.at(anyIn: AccessorDeclSyntax.AccessorSpecifierOptions.self) ?? forcedKind else {
       return nil
     }
 
     let attrs = self.parseAttributeList()
-
-    // Parse the contextual keywords for 'mutating' and 'nonmutating' before
-    // get and set.
-    let modifier: RawDeclModifierSyntax?
-    if hasModifier {
-      let (unexpectedBeforeName, name) = self.expect(anyIn: AccessorModifier.self, default: .mutating)
-      modifier = RawDeclModifierSyntax(
-        unexpectedBeforeName,
-        name: name,
-        detail: nil,
-        arena: self.arena
-      )
-    } else {
-      modifier = nil
-    }
+    let modifiers = self.parseAccessorModifierList(count: modifierCount)
 
     let (unexpectedBeforeIntroducer, introducer) = self.expect(kind.spec)
+
     return AccessorIntroducer(
       attributes: attrs,
-      modifier: modifier,
+      modifiers: modifiers,
       kind: kind,
       unexpectedBeforeToken: unexpectedBeforeIntroducer,
       token: introducer
@@ -1738,7 +1745,7 @@ extension Parser {
     let body = self.parseOptionalCodeBlock()
     return RawAccessorDeclSyntax(
       attributes: introducer.attributes,
-      modifier: introducer.modifier,
+      modifiers: introducer.modifiers,
       introducer.unexpectedBeforeToken,
       accessorSpecifier: introducer.token,
       parameters: parameters,

Sources/SwiftParser/Lookahead.swift

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

Sources/SwiftParser/TokenPrecedence.swift

@@ -237,7 +237,7 @@ enum TokenPrecedence: Comparable {
       .dependsOn, .scoped, .sending,
       // Accessors
       .get, .set, .didSet, .willSet, .unsafeAddress, .addressWithOwner, .addressWithNativeOwner, .unsafeMutableAddress,
-      .mutableAddressWithOwner, .mutableAddressWithNativeOwner, ._read, .read, ._modify, .modify, .mutate,
+      .mutableAddressWithOwner, .mutableAddressWithNativeOwner, ._read, .read, ._modify, .modify, .mutate, .yielding,
       // Misc
       .import, .using:
       self = .declKeyword

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)
     }
   }
 }

Sources/SwiftSyntax/SwiftSyntaxCompatibility.swift

@@ -13,6 +13,36 @@
 // This file provides compatibility aliases to keep dependents of SwiftSyntax building.
 // All users of the declarations in this file should transition away from them ASAP.
 
+extension AccessorDeclSyntax {
+  @available(*, deprecated, message: "use modifiers to see all modifiers on an accessor declaration")
+  public var modifier: DeclModifierSyntax? {
+    get {
+      // The legacy `modifier` API predates `yielding`
+      if let m = modifiers.first(where: { $0.name.text != "yielding" }) {
+        return m
+      }
+      return nil
+    }
+    set {
+      if let newValue {
+        modifiers = [newValue]
+      } else {
+        modifiers = []
+      }
+    }
+  }
+  @available(*, deprecated, message: "use unexpectedBetweenAttributesAndModifers")
+  public var unexpectedBetweenAttributesAndModifier: UnexpectedNodesSyntax? {
+    get { unexpectedBetweenAttributesAndModifiers }
+    set { unexpectedBetweenAttributesAndModifiers = newValue }
+  }
+  @available(*, deprecated, message: "use unexpectedBetweenModifiersAndAccessorSpecifier")
+  public var unexpectedBetweenModifierAndAccessorSpecifier: UnexpectedNodesSyntax? {
+    get { unexpectedBetweenModifiersAndAccessorSpecifier }
+    set { unexpectedBetweenModifiersAndAccessorSpecifier = newValue }
+  }
+}
+
 extension AccessorEffectSpecifiersSyntax {
   @_disfavoredOverload
   @available(*, deprecated, message: "use throwsClause instead of throwsSpecifier")