improve diagnostic for unnamed closure parameters

- instead of treating as unrecognized, try to parse the remaining tokens as a type even if the preceding colon is missing

Author: AppAppWorks

Sources/SwiftParser/Parameters.swift

@@ -160,10 +160,23 @@ extension Parser {
     let misplacedSpecifiers = parseMisplacedSpecifiers()
 
     let names = self.parseParameterNames()
-    let colon = self.consume(if: .colon)
+    var colon = self.consume(if: .colon)
+    // try to parse the type regardless of the presence of the preceding colon
+    // because the parameter may be unnamed
+    // e.g. [X] or (:[X])
+    let canParseType = withLookahead { $0.canParseType() }
     let type: RawTypeSyntax?
-    if colon != nil {
+    if canParseType {
       type = self.parseType(misplacedSpecifiers: misplacedSpecifiers)
+      if colon == nil {
+        // mark the preceding colon as missing if the parameter is unnamed
+        // e.g. [X]
+        colon = missingToken(.colon)
+      }
+    } else if colon != nil {
+      // mark the type as missing if the preceding colon is present
+      // e.g. (_:)
+      type = RawTypeSyntax(RawMissingTypeSyntax(arena: self.arena))
     } else {
       type = nil
     }

Tests/SwiftParserTest/ExpressionTests.swift

@@ -2875,6 +2875,56 @@ final class StatementExpressionTests: ParserTestCase {
     )
   }
 
+  func testClosureWithMalformedParameters() {
+    assertParse(
+      """
+      test { (1️⃣[X]) in }
+      """,
+      diagnostics: [
+        DiagnosticSpec(message: "expected identifier and ':' in parameter", fixIts: ["insert identifier and ':'"])
+      ],
+      fixedSource: """
+        test { (<#identifier#>: [X]) in }
+        """
+    )
+
+    assertParse(
+      """
+      test { (1️⃣: [X]) in }
+      """,
+      diagnostics: [
+        DiagnosticSpec(message: "expected identifier in parameter", fixIts: ["insert identifier"])
+      ],
+      fixedSource: """
+        test { (<#identifier#>: [X]) in }
+        """
+    )
+
+    assertParse(
+      """
+      test { (foo1️⃣ @bar baz) in }
+      """,
+      diagnostics: [
+        DiagnosticSpec(message: "expected ':' in parameter", fixIts: ["insert ':'"])
+      ],
+      fixedSource: """
+        test { (foo: @bar baz) in }
+        """
+    )
+
+    assertParse(
+      """
+      test { (x: 1️⃣) in }
+      """,
+      diagnostics: [
+        DiagnosticSpec(message: "expected type in parameter", fixIts: ["insert type"])
+      ],
+      fixedSource: """
+        test { (x: <#type#>) in }
+        """
+    )
+  }
+
   func testTypedThrowsDisambiguation() {
     assertParse(
       "[() throws(MyError) 1️⃣async -> Void]()",