[SwiftParser] Diagnose missing 'in' after closure signature

Teach SwiftSyntax to mirror the compiler's missing-'in' closure diagnostic: 'canParseClosureSignature' now only succeeds without 'in' when a top-level arrow was seen, 'ParseDiagnosticsGenerator' reports both the "unexpected tokens prior to 'in'" and "expected 'in' after the closure signature" diagnostics with the appropriate fix-it, the diagnostic strings are exposed for clients, the new closure-focused test suite verifies the scenarios the compiler added, and Recovery test 141 is updated to expect the extra diagnostic and rewritten source.

Author: kwikysw

Sources/SwiftParser/Expressions.swift

@@ -2567,6 +2567,7 @@ extension Parser.Lookahead {
   mutating func canParseClosureSignature() -> Bool {
     // Consume attributes.
     var lookahead = self.lookahead()
+    var sawTopLevelArrowInLookahead = false
     var attributesProgress = LoopProgressCondition()
     while lookahead.consume(if: .atSign) != nil, lookahead.hasProgressed(&attributesProgress) {
       guard lookahead.at(.identifier) else {
@@ -2630,15 +2631,21 @@ extension Parser.Lookahead {
         return false
       }
 
+      sawTopLevelArrowInLookahead = true
+
       lookahead.consumeEffectsSpecifiers()
     }
 
     // Parse the 'in' at the end.
-    guard lookahead.at(.keyword(.in)) else {
-      return false
+    if lookahead.at(.keyword(.in)) {
+      // Okay, we have a closure signature.
+      return true
     }
-    // Okay, we have a closure signature.
-    return true
+
+    // Even if 'in' is missing, the presence of a top-level '->' makes this look like a
+    // closure signature. There's no other valid syntax that could legally
+    // contain '->' at this position.
+    return sawTopLevelArrowInLookahead
   }
 }
 

Sources/SwiftParserDiagnostics/ParseDiagnosticsGenerator.swift

@@ -744,6 +744,49 @@ public class ParseDiagnosticsGenerator: SyntaxAnyVisitor {
     if shouldSkip(node) {
       return .skipChildren
     }
+    if let unexpected = node.unexpectedBetweenReturnClauseAndInKeyword,
+      let tokens = unexpected.onlyPresentTokens(satisfying: { _ in true }),
+      !tokens.isEmpty
+    {
+      addDiagnostic(
+        unexpected,
+        .unexpectedTokensPriorToIn,
+        handledNodes: [unexpected.id]
+      )
+      let baseInKeyword: TokenSyntax =
+        node.inKeyword.isMissing
+        ? node.inKeyword
+        : node.inKeyword.with(\.presence, .missing)
+      let adjustedInKeyword =
+        baseInKeyword
+        .with(\.leadingTrivia, tokens.first?.leadingTrivia ?? baseInKeyword.leadingTrivia)
+        .with(\.trailingTrivia, [])
+      addDiagnostic(
+        unexpected,
+        .expectedInAfterClosureSignature,
+        fixIts: [
+          FixIt(
+            message: InsertTokenFixIt(missingNodes: [Syntax(adjustedInKeyword)]),
+            changes: [.makePresent(adjustedInKeyword)]
+          )
+        ],
+        handledNodes: [adjustedInKeyword.id]
+      )
+    }
+
+    if node.inKeyword.isMissing {
+      addDiagnostic(
+        node.inKeyword,
+        .expectedInAfterClosureSignature,
+        fixIts: [
+          FixIt(
+            message: InsertTokenFixIt(missingNodes: [Syntax(node.inKeyword)]),
+            changes: [.makePresent(node.inKeyword)]
+          )
+        ],
+        handledNodes: [node.inKeyword.id]
+      )
+    }
     handleMisplacedEffectSpecifiers(effectSpecifiers: node.effectSpecifiers, output: node.returnClause)
     return .visitChildren
   }

Sources/SwiftParserDiagnostics/ParserDiagnosticMessages.swift

@@ -140,6 +140,9 @@ extension DiagnosticMessage where Self == StaticParserError {
   public static var expectedExpressionAfterTry: Self {
     .init("expected expression after 'try'")
   }
+  public static var expectedInAfterClosureSignature: Self {
+    .init("expected 'in' after the closure signature")
+  }
   public static var expectedAssignmentInsteadOfComparisonOperator: Self {
     .init("expected '=' instead of '==' to assign default value for parameter")
   }
@@ -266,6 +269,9 @@ extension DiagnosticMessage where Self == StaticParserError {
   public static var unexpectedSemicolon: Self {
     .init("unexpected ';' separator")
   }
+  public static var unexpectedTokensPriorToIn: Self {
+    .init("unexpected tokens prior to 'in'")
+  }
   public static var versionComparisonNotNeeded: Self {
     .init("version comparison not needed")
   }

Tests/SwiftParserTest/ClosureMissingInTests.swift

@@ -0,0 +1,117 @@
+@_spi(ExperimentalLanguageFeatures) @_spi(RawSyntax) import SwiftParser
+@_spi(ExperimentalLanguageFeatures) @_spi(RawSyntax) import SwiftSyntax
+import XCTest
+
+final class ClosureMissingInTests: ParserTestCase {
+
+  func testMissingInAfterSignature() {
+    assertParse(
+      """
+      _ = { (x: Int) -> Int 1️⃣0 }
+      """,
+      diagnostics: [
+        DiagnosticSpec(
+          locationMarker: "1️⃣",
+          message: "expected 'in' after the closure signature",
+          fixIts: ["insert 'in'"]
+        )
+      ],
+      fixedSource: """
+        _ = { (x: Int) -> Int in 0 }
+        """
+    )
+  }
+
+  func testArrayLiteralNotMisparsedAsSignature() {
+    assertParse(
+      """
+      _ = { [x, y] }
+      """
+    )
+  }
+
+  func testAsyncIsNotASignatureGate() {
+    assertParse(
+      """
+      _ = { async }
+      """
+    )
+  }
+
+  func testShorthandParamsWithReturnType() {
+    assertParse(
+      """
+      _ = { x, _ -> Int 1️⃣x }
+      """,
+      diagnostics: [
+        DiagnosticSpec(
+          locationMarker: "1️⃣",
+          message: "expected 'in' after the closure signature",
+          fixIts: ["insert 'in'"]
+        )
+      ],
+      fixedSource: """
+        _ = { x, _ -> Int in x }
+        """
+    )
+  }
+
+  func testResyncTokensBeforeIn() {
+    assertParse(
+      """
+      _ = { () -> Int
+        1️⃣2️⃣0
+        in
+        1
+      }
+      """,
+      diagnostics: [
+        DiagnosticSpec(
+          locationMarker: "1️⃣",
+          message: "unexpected tokens prior to 'in'"
+        ),
+        DiagnosticSpec(
+          locationMarker: "2️⃣",
+          message: "expected 'in' after the closure signature",
+          fixIts: ["insert 'in'"]
+        ),
+      ],
+      fixedSource:
+        """
+        _ = { () -> Int
+          0
+          in 
+          in
+          1
+        }
+        """
+    )
+  }
+
+  func testMissingInInFunctionArgument() {
+    assertParse(
+      """
+      test(make: { () -> [Int] 1️⃣
+        return [3]
+      }, consume: { _ in
+        print("Test")
+      })
+      """,
+      diagnostics: [
+        DiagnosticSpec(
+          locationMarker: "1️⃣",
+          message: "expected 'in' after the closure signature",
+          fixIts: ["insert 'in'"]
+        )
+      ],
+      fixedSource:
+        """
+        test(make: { () -> [Int] in
+          return [3]
+        }, consume: { _ in
+          print("Test")
+        })
+        """
+    )
+  }
+}

Tests/SwiftParserTest/translated/RecoveryTests.swift

@@ -2445,6 +2445,11 @@ final class RecoveryTests: ParserTestCase {
           locationMarker: "3️⃣",
           message: "unexpected code '[' in function"
         ),
+        DiagnosticSpec(
+          locationMarker: "4️⃣",
+          message: "expected 'in' after the closure signature",
+          fixIts: ["insert 'in'"]
+        ),
         DiagnosticSpec(
           locationMarker: "4️⃣",
           message: "unexpected code ') -> Int {}' in closure"
@@ -2453,7 +2458,7 @@ final class RecoveryTests: ParserTestCase {
       fixedSource: """
         #if true
         struct Foo19605164 {
-        func a(s: S) [{{g) -> Int {}
+        func a(s: S) [{{g in) -> Int {}
         }}}
         #endif
         """