[SwiftParser] Implement nonisolated(nonsending) specifier

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:

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/Attributes.swift

@@ -157,7 +157,7 @@ extension Parser {
       shouldParseArgument = true
     case .customAttribute:
       shouldParseArgument =
-        self.withLookahead { $0.atCustomAttributeArgument() }
+        self.withLookahead { $0.atAttributeOrSpecifierArgument() }
         && self.at(TokenSpec(.leftParen, allowAtStartOfLine: false))
     case .optional:
       shouldParseArgument = self.at(.leftParen)
@@ -1002,7 +1002,7 @@ extension Parser {
 // MARK: Lookahead
 
 extension Parser.Lookahead {
-  mutating func atCustomAttributeArgument() -> Bool {
+  mutating func atAttributeOrSpecifierArgument() -> Bool {
     var lookahead = self.lookahead()
     lookahead.skipSingle()
 
@@ -1036,7 +1036,7 @@ extension Parser.Lookahead {
     }
 
     if self.at(TokenSpec(.leftParen, allowAtStartOfLine: false))
-      && self.withLookahead({ $0.atCustomAttributeArgument() })
+      && self.withLookahead({ $0.atAttributeOrSpecifierArgument() })
     {
       self.skipSingle()
     }

Sources/SwiftParser/Modifiers.swift

@@ -236,7 +236,11 @@ extension Parser {
     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(
+        TokenSpec(.unsafe, remapping: .identifier),
+        TokenSpec(.nonsending, remapping: .identifier),
+        default: TokenSpec(.identifier)
+      )
       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/SwiftParser/Types.swift

@@ -689,13 +689,28 @@ extension Parser.Lookahead {
 
   mutating func skipTypeAttributeList() {
     var specifierProgress = LoopProgressCondition()
-    // TODO: Can we model isolated/_const so that they're specified in both canParse* and parse*?
     while canHaveParameterSpecifier,
-      self.at(anyIn: SimpleTypeSpecifierSyntax.SpecifierOptions.self) != nil || self.at(.keyword(.isolated))
-        || self.at(.keyword(._const)),
+      self.at(anyIn: SimpleTypeSpecifierSyntax.SpecifierOptions.self) != nil
+        || self.at(.keyword(.nonisolated), .keyword(.dependsOn)),
       self.hasProgressed(&specifierProgress)
     {
-      self.consumeAnyToken()
+      switch self.currentToken {
+      case .keyword(.nonisolated), .keyword(.dependsOn):
+        self.consumeAnyToken()
+
+        // The argument is missing but it still could be a valid modifier,
+        // i.e. `nonisolated` in an inheritance clause.
+        guard self.at(TokenSpec(.leftParen, allowAtStartOfLine: false)) else {
+          continue
+        }
+
+        if self.withLookahead({ $0.atAttributeOrSpecifierArgument() }) {
+          skipSingle()
+        }
+
+      default:
+        self.consumeAnyToken()
+      }
     }
 
     var attributeProgress = LoopProgressCondition()
@@ -1056,6 +1071,88 @@ extension Parser {
     return .lifetimeTypeSpecifier(lifetimeSpecifier)
   }
 
+  private mutating func parseNonisolatedTypeSpecifier() -> RawTypeSpecifierListSyntax.Element {
+    let (unexpectedBeforeNonisolatedKeyword, nonisolatedKeyword) = self.expect(.keyword(.nonisolated))
+
+    // If the next token is not '(' this could mean two things:
+    //  - What follows is a type and we should allow it because
+    //    using `nonsisolated` without an argument is allowed in
+    //    an inheritance clause.
+    //  - The '(nonsending)' was omitted.
+    if !self.at(.leftParen) {
+      // `nonisolated P<...>` is allowed in an inheritance clause.
+      if withLookahead({ $0.canParseTypeIdentifier() }) {
+        let nonisolatedSpecifier = RawNonisolatedTypeSpecifierSyntax(
+          unexpectedBeforeNonisolatedKeyword,
+          nonisolatedKeyword: nonisolatedKeyword,
+          argument: nil,
+          arena: self.arena
+        )
+        return .nonisolatedTypeSpecifier(nonisolatedSpecifier)
+      }
+
+      // Otherwise require '(nonsending)'
+      let argument = RawNonisolatedSpecifierArgumentSyntax(
+        leftParen: missingToken(.leftParen),
+        nonsendingKeyword: missingToken(.keyword(.nonsending)),
+        rightParen: missingToken(.rightParen),
+        arena: self.arena
+      )
+
+      let nonisolatedSpecifier = RawNonisolatedTypeSpecifierSyntax(
+        unexpectedBeforeNonisolatedKeyword,
+        nonisolatedKeyword: nonisolatedKeyword,
+        argument: argument,
+        arena: self.arena
+      )
+
+      return .nonisolatedTypeSpecifier(nonisolatedSpecifier)
+    }
+
+    // Avoid being to greedy about `(` since this modifier should be associated with
+    // function types, it's possible that the argument is omitted and what follows
+    // is a function type i.e. `nonisolated () async -> Void`.
+    if self.at(.leftParen) && !withLookahead({ $0.atAttributeOrSpecifierArgument() }) {
+      let argument = RawNonisolatedSpecifierArgumentSyntax(
+        leftParen: missingToken(.leftParen),
+        nonsendingKeyword: missingToken(.keyword(.nonsending)),
+        rightParen: missingToken(.rightParen),
+        arena: self.arena
+      )
+
+      let nonisolatedSpecifier = RawNonisolatedTypeSpecifierSyntax(
+        unexpectedBeforeNonisolatedKeyword,
+        nonisolatedKeyword: nonisolatedKeyword,
+        argument: argument,
+        arena: self.arena
+      )
+
+      return .nonisolatedTypeSpecifier(nonisolatedSpecifier)
+    }
+
+    let (unexpectedBeforeLeftParen, leftParen) = self.expect(.leftParen)
+    let (unexpectedBeforeModifier, modifier) = self.expect(.keyword(.nonsending))
+    let (unexpectedBeforeRightParen, rightParen) = self.expect(.rightParen)
+
+    let argument = RawNonisolatedSpecifierArgumentSyntax(
+      unexpectedBeforeLeftParen,
+      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 +1176,13 @@ extension Parser {
         } else {
           break SPECIFIER_PARSING
         }
+      } else if self.at(.keyword(.nonisolated)) {
+        // If '(' is located on the new line 'nonisolated' cannot be parsed
+        // as a specifier.
+        if self.peek(isAt: .leftParen) && self.peek().isAtStartOfLine {
+          break SPECIFIER_PARSING
+        }
+        specifiers.append(parseNonisolatedTypeSpecifier())
       } else {
         break SPECIFIER_PARSING
       }

Sources/SwiftParserDiagnostics/SyntaxExtensions.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()