[SwiftParser] Allow nonisolated to accept nonsending modifier

Author: xedin

CodeGeneration/Sources/SyntaxSupport/KeywordSpec.swift

@@ -210,6 +210,7 @@ public enum Keyword: CaseIterable {
   case none
   case nonisolated
   case nonmutating
+  case nonsending
   case objc
   case obsoleted
   case of
@@ -551,6 +552,8 @@ public enum Keyword: CaseIterable {
       return KeywordSpec("nonisolated")
     case .nonmutating:
       return KeywordSpec("nonmutating")
+    case .nonsending:
+      return KeywordSpec("nonsending")
     case .objc:
       return KeywordSpec("objc")
     case .obsoleted:

Sources/SwiftParser/Modifiers.swift

@@ -231,12 +231,35 @@ extension Parser {
   }
 
   mutating func parseNonisolatedModifier(_ handle: RecoveryConsumptionHandle) -> RawDeclModifierSyntax {
+    enum NonIsolatedModifier: TokenSpecSet {
+      case unsafe
+      case nonsending
+
+      var spec: TokenSpec {
+        switch self {
+        case .unsafe: return .keyword(.unsafe)
+        case .nonsending: return .keyword(.nonsending)
+        }
+      }
+
+      init?(lexeme: Lexer.Lexeme, experimentalFeatures: Parser.ExperimentalFeatures) {
+        switch PrepareForKeywordMatch(lexeme) {
+        case TokenSpec(.unsafe): self = .unsafe
+        case TokenSpec(.nonsending): self = .nonsending
+        default: return nil
+        }
+      }
+    }
+
     let (unexpectedBeforeKeyword, keyword) = self.eat(handle)
 
     let detail: RawDeclModifierDetailSyntax?
     if self.at(.leftParen) {
       let (unexpectedBeforeLeftParen, leftParen) = self.expect(.leftParen)
-      let (unexpectedBeforeDetailToken, detailToken) = self.expect(TokenSpec(.unsafe, remapping: .identifier))
+      let (unexpectedBeforeDetailToken, detailToken) = self.expect(
+        anyIn: NonIsolatedModifier.self,
+        default: .unsafe
+      )
       let (unexpectedBeforeRightParen, rightParen) = self.expect(.rightParen)
       detail = RawDeclModifierDetailSyntax(
         unexpectedBeforeLeftParen,

Sources/SwiftParser/TokenPrecedence.swift

@@ -326,6 +326,7 @@ enum TokenPrecedence: Comparable {
       .module,
       .noasync,
       .none,
+      .nonsending,
       .obsoleted,
       .of,
       .Protocol,

Sources/SwiftSyntax/generated/Keyword.swift

@@ -277,6 +277,35 @@ final class DeclarationTests: ParserTestCase {
     )
   }
 
+  func testNonisolatedNonSendingParsing() {
+    assertParse(
+      """
+      nonisolated(nonsending) let a = 0
+
+      struct A {
+        nonisolated(nonsending) let b = 0
+        nonisolated(nonsending) var c: Int { 0 }
+        nonisolated(1️⃣sending) let d = 0
+      }
+      """,
+      diagnostics: [
+        DiagnosticSpec(
+          message: "expected 'unsafe' in modifier",
+          fixIts: ["replace 'sending' with 'unsafe'"]
+        )
+      ],
+      fixedSource: """
+        nonisolated(nonsending) let a = 0
+
+        struct A {
+          nonisolated(nonsending) let b = 0
+          nonisolated(nonsending) var c: Int { 0 }
+          nonisolated(unsafe) let d = 0
+        }
+        """
+    )
+  }
+
   func testProtocolParsing() {
     assertParse("protocol Foo {}")