[SwiftParser] Diagnose missing 'in' after closure signature

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
  """