[SwiftParser] Allow nonisolated modifier to have a single nonsending argument

This is part of SE-0461 proposal where `nonisolated` has to be
marked as `nonsending` in type context to indicate that the
function type it's attached to is caller isolated.

Author: xedin

CodeGeneration/Sources/SyntaxSupport/SyntaxNodeKind.swift

@@ -210,6 +210,9 @@ public enum SyntaxNodeKind: String, CaseIterable, IdentifierConvertible, TypeCon
   case multipleTrailingClosureElementList
   case namedOpaqueReturnType
   case nilLiteralExpr
+  case nonisolatedSpecifierArgument
+  case nonisolatedSpecifierArgumentList
+  case nonisolatedTypeSpecifier
   case objCSelectorPiece
   case objCSelectorPieceList
   case operatorDecl

CodeGeneration/Sources/SyntaxSupport/TypeNodes.swift

@@ -676,6 +676,52 @@ public let TYPE_NODES: [Node] = [
     ]
   ),
 
+  Node(
+    kind: .nonisolatedSpecifierArgument,
+    base: .syntax,
+    nameForDiagnostics: nil,
+    documentation: """
+      A single argument that can be added to a nonisolated specifier: 'nonsending'.
+
+      ### Example
+      `data` in `func foo(data: nonisolated(nonsending) () async -> Void) -> X`
+      """,
+    traits: [
+      "Parenthesized"
+    ],
+    children: [
+      Child(
+        name: "leftParen",
+        kind: .token(choices: [.token(.leftParen)])
+      ),
+      Child(
+        name: "nonsendingKeyword",
+        kind: .token(choices: [.keyword(.nonsending)])
+      ),
+      Child(
+        name: "rightParen",
+        kind: .token(choices: [.token(.rightParen)])
+      ),
+    ]
+  ),
+
+  Node(
+    kind: .nonisolatedTypeSpecifier,
+    base: .syntax,
+    nameForDiagnostics: "'nonisolated' specifier",
+    children: [
+      Child(
+        name: "nonisolatedKeyword",
+        kind: .token(choices: [.keyword(.nonisolated)])
+      ),
+      Child(
+        name: "argument",
+        kind: .node(kind: .nonisolatedSpecifierArgument),
+        isOptional: true
+      ),
+    ]
+  ),
+
   Node(
     kind: .simpleTypeSpecifier,
     base: .syntax,
@@ -689,7 +735,6 @@ public let TYPE_NODES: [Node] = [
           .keyword(.__shared),
           .keyword(.__owned),
           .keyword(.isolated),
-          .keyword(.nonisolated),
           .keyword(._const),
           .keyword(.borrowing),
           .keyword(.consuming),
@@ -704,6 +749,6 @@ public let TYPE_NODES: [Node] = [
     kind: .typeSpecifierList,
     base: .syntaxCollection,
     nameForDiagnostics: nil,
-    elementChoices: [.simpleTypeSpecifier, .lifetimeTypeSpecifier]
+    elementChoices: [.simpleTypeSpecifier, .lifetimeTypeSpecifier, .nonisolatedTypeSpecifier]
   ),
 ]

Sources/SwiftParser/Types.swift

@@ -1056,6 +1056,40 @@ extension Parser {
     return .lifetimeTypeSpecifier(lifetimeSpecifier)
   }
 
+  private mutating func parseNonisolatedTypeSpecifier() -> RawTypeSpecifierListSyntax.Element {
+    let (unexpectedBeforeNonisolatedKeyword, nonisolatedKeyword) = self.expect(.keyword(.nonisolated))
+
+    guard let leftParen = self.consume(if: .leftParen) else {
+      let nonisolatedSpecifier = RawNonisolatedTypeSpecifierSyntax(
+        unexpectedBeforeNonisolatedKeyword,
+        nonisolatedKeyword: nonisolatedKeyword,
+        argument: nil,
+        arena: self.arena
+      )
+      return .nonisolatedTypeSpecifier(nonisolatedSpecifier)
+    }
+
+    let (unexpectedBeforeModifier, modifier) = self.expect(.keyword(.nonsending))
+    let (unexpectedBeforeRightParen, rightParen) = self.expect(.rightParen)
+
+    let argument = RawNonisolatedSpecifierArgumentSyntax(
+      leftParen: leftParen,
+      unexpectedBeforeModifier,
+      nonsendingKeyword: modifier,
+      unexpectedBeforeRightParen,
+      rightParen: rightParen,
+      arena: self.arena
+    )
+
+    let nonisolatedSpecifier = RawNonisolatedTypeSpecifierSyntax(
+      unexpectedBeforeNonisolatedKeyword,
+      nonisolatedKeyword: nonisolatedKeyword,
+      argument: argument,
+      arena: self.arena
+    )
+    return .nonisolatedTypeSpecifier(nonisolatedSpecifier)
+  }
+
   private mutating func parseSimpleTypeSpecifier(
     specifierHandle: TokenConsumptionHandle
   ) -> RawTypeSpecifierListSyntax.Element {
@@ -1079,6 +1113,8 @@ extension Parser {
         } else {
           break SPECIFIER_PARSING
         }
+      } else if self.at(.keyword(.nonisolated)) {
+        specifiers.append(parseNonisolatedTypeSpecifier())
       } else {
         break SPECIFIER_PARSING
       }

Sources/SwiftParser/generated/Parser+TokenSpecSet.swift

@@ -212,6 +212,7 @@ extension TypeSpecifierListSyntax {
       switch specifier {
       case .simpleTypeSpecifier(let specifier): return specifier.specifier
       case .lifetimeTypeSpecifier: return nil
+      case .nonisolatedTypeSpecifier: return nil
       #if RESILIENT_LIBRARIES
       @unknown default:
         fatalError()