Add diagnostic for missing condition binding

Author: kimdv

Sources/SwiftParser/Statements.swift

@@ -186,7 +186,7 @@ extension Parser {
     var keepGoing: RawTokenSyntax? = nil
     var loopProgress = LoopProgressCondition()
     repeat {
-      let condition = self.parseConditionElement()
+      let condition = self.parseConditionElement(lastBindingKind: elements.last?.condition.as(RawOptionalBindingConditionSyntax.self)?.bindingKeyword)
       let unexpectedBeforeKeepGoing: RawUnexpectedNodesSyntax?
       keepGoing = self.consume(if: .comma)
       if keepGoing == nil, let andOperator = self.consumeIfContextualPunctuator("&&") {
@@ -219,15 +219,15 @@ extension Parser {
   ///     optional-binding-condition → 'let' pattern initializer? | 'var' pattern initializer? |
   ///                                  'inout' pattern initializer?
   @_spi(RawSyntax)
-  public mutating func parseConditionElement() -> RawConditionElementSyntax.Condition {
+  public mutating func parseConditionElement(lastBindingKind: RawTokenSyntax?) -> RawConditionElementSyntax.Condition {
     // Parse a leading #available/#unavailable condition if present.
     if self.at(.poundAvailableKeyword, .poundUnavailableKeyword) {
       return self.parsePoundAvailableConditionElement()
     }
 
     // Parse the basic expression case.  If we have a leading let, var, inout,
     // borrow, case keyword or an assignment, then we know this is a binding.
-    guard self.at(.keyword(.let), .keyword(.var), .keyword(.case)) || self.at(.keyword(.inout)) else {
+    guard self.at(.keyword(.let), .keyword(.var), .keyword(.case)) || self.at(.keyword(.inout)) || (lastBindingKind != nil && self.peek().rawTokenKind == .equal) else {
       // If we lack it, then this is theoretically a boolean condition.
       // However, we also need to handle migrating from Swift 2 syntax, in
       // which a comma followed by an expression could actually be a pattern
@@ -244,20 +244,20 @@ extension Parser {
     }
 
     // We're parsing a conditional binding.
-    precondition(self.at(.keyword(.let), .keyword(.var)) || self.at(.keyword(.inout), .keyword(.case)))
     enum BindingKind {
       case pattern(RawTokenSyntax, RawPatternSyntax)
-      case optional(RawTokenSyntax, RawPatternSyntax)
+      case optional(RawUnexpectedNodesSyntax?, RawTokenSyntax, RawPatternSyntax)
     }
 
     let kind: BindingKind
     if let caseKeyword = self.consume(if: .keyword(.case)) {
       let pattern = self.parseMatchingPattern(context: .matching)
       kind = .pattern(caseKeyword, pattern)
     } else {
-      let letOrVar = self.consumeAnyToken()
+      let (unexpectedBeforeBindingKeyword, letOrVar) = self.expect(.keyword(.let), .keyword(.var), default: .keyword(Keyword(lastBindingKind!.tokenText)!))
+
       let pattern = self.parseMatchingPattern(context: .bindingIntroducer)
-      kind = .optional(letOrVar, pattern)
+      kind = .optional(unexpectedBeforeBindingKeyword, letOrVar, pattern)
     }
 
     // Now parse an optional type annotation.
@@ -289,9 +289,10 @@ extension Parser {
     }
 
     switch kind {
-    case let .optional(bindingKeyword, pattern):
+    case let .optional(unexpectedBeforeBindingKeyword, bindingKeyword, pattern):
       return .optionalBinding(
         RawOptionalBindingConditionSyntax(
+          unexpectedBeforeBindingKeyword,
           bindingKeyword: bindingKeyword,
           pattern: pattern,
           typeAnnotation: annotation,

Sources/SwiftParserDiagnostics/ParseDiagnosticsGenerator.swift

@@ -935,6 +935,28 @@ public class ParseDiagnosticsGenerator: SyntaxAnyVisitor {
     return .visitChildren
   }
 
+  public override func visit(_ node: OptionalBindingConditionSyntax) -> SyntaxVisitorContinueKind {
+    if shouldSkip(node) {
+      return .skipChildren
+    }
+
+    if node.bindingKeyword.presence == .missing {
+      addDiagnostic(
+        node.bindingKeyword,
+        ExpectedBindingKeyword(token: node.bindingKeyword),
+        fixIts: [
+          FixIt(
+            message: InsertFixIt(tokenToBeInserted: node.bindingKeyword),
+            changes: [.makePresent(node.bindingKeyword)]
+          )
+        ],
+        handledNodes: [node.bindingKeyword.id]
+      )
+    }
+
+    return .visitChildren
+  }
+
   public override func visit(_ node: PrecedenceGroupAssignmentSyntax) -> SyntaxVisitorContinueKind {
     if shouldSkip(node) {
       return .skipChildren

Sources/SwiftParserDiagnostics/ParserDiagnosticMessages.swift

@@ -266,6 +266,14 @@ public struct EffectsSpecifierAfterArrow: ParserError {
   }
 }
 
+public struct ExpectedBindingKeyword: ParserError {
+  let token: TokenSyntax
+
+  public var message: String {
+    return "expected '\(token.text)' in conditional"
+  }
+}
+
 public struct ExtaneousCodeAtTopLevel: ParserError {
   public let extraneousCode: UnexpectedNodesSyntax
 
@@ -536,6 +544,14 @@ extension FixItMessage where Self == StaticParserFixIt {
   }
 }
 
+public struct InsertFixIt: ParserFixIt {
+  public let tokenToBeInserted: TokenSyntax
+
+  public var message: String {
+    "insert '\(tokenToBeInserted.text)'"
+  }
+}
+
 public struct MoveTokensAfterFixIt: ParserFixIt {
   /// The token that should be moved
   public let movedTokens: [TokenSyntax]

Tests/SwiftParserTest/translated/RecoveryTests.swift

@@ -1839,13 +1839,18 @@ final class RecoveryTests: XCTestCase {
   func testRecovery153() {
     assertParse(
       """
-      if var y = x, z = x {
+      if var y = x, 1️⃣z = x {
         z = y; y = z
       }
       """,
       diagnostics: [
-        // TODO: Old parser expected error on line 1: expected 'var' in conditional, Fix-It replacements: 17 - 17 = 'var '
-      ]
+        DiagnosticSpec(message: "expected 'var' in conditional", fixIts: ["insert 'var'"])
+      ],
+      fixedSource: """
+        if var y = x, var z = x {
+          z = y; y = z
+        }
+        """
     )
   }