[SwiftParser] Make nonisolated(nonsending) parsing check before consuming '('

It's possible that `(nonsending)` was omitted and instead we are
at the parameter list of a function type. Checking ahead allows
for a better diagnostics and recovery.

Author: xedin

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

@@ -1059,6 +1059,27 @@ extension Parser {
   private mutating func parseNonisolatedTypeSpecifier() -> RawTypeSpecifierListSyntax.Element {
     let (unexpectedBeforeNonisolatedKeyword, nonisolatedKeyword) = self.expect(.keyword(.nonisolated))
 
+    // 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)
+    }
+
+    // nonisolated without an argument is valid in some positions i.e. inheritance clause.
     guard let leftParen = self.consume(if: .leftParen) else {
       let nonisolatedSpecifier = RawNonisolatedTypeSpecifierSyntax(
         unexpectedBeforeNonisolatedKeyword,

Tests/SwiftParserTest/TypeTests.swift

@@ -546,10 +546,23 @@ final class TypeTests: ParserTestCase {
     assertParse("func foo(test: nonisolated(nonsending) () async -> Void)")
     assertParse("func foo(test: nonisolated(nonsending) @escaping () async -> Void) {}")
 
+    assertParse(
+      "func foo(test: nonisolated1️⃣ () async -> Void)",
+      diagnostics: [
+        DiagnosticSpec(
+          locationMarker: "1️⃣",
+          message: "expected '(nonsending)' in 'nonisolated' specifier",
+          fixIts: ["insert '(nonsending)'"]
+        )
+      ],
+      fixedSource: "func foo(test: nonisolated(nonsending) () async -> Void)"
+    )
+
     assertParse(
       "func foo(test: nonisolated(1️⃣) () async -> Void)",
       diagnostics: [
         DiagnosticSpec(
+          locationMarker: "1️⃣",
           message: "expected 'nonsending' in 'nonisolated' specifier",
           fixIts: ["insert 'nonsending'"]
         )
@@ -561,6 +574,7 @@ final class TypeTests: ParserTestCase {
       "func foo(test: nonisolated(1️⃣hello) () async -> Void)",
       diagnostics: [
         DiagnosticSpec(
+          locationMarker: "1️⃣",
           message: "expected 'nonsending' in 'nonisolated' specifier",
           fixIts: ["insert 'nonsending'"]
         ),