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,7 +244,6 @@ 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)
@@ -255,7 +254,14 @@ extension Parser {
       let pattern = self.parseMatchingPattern(context: .matching)
       kind = .pattern(caseKeyword, pattern)
     } else {
-      let letOrVar = self.consumeAnyToken()
+      let letOrVar: RawTokenSyntax
+
+      if self.at(.identifier) {
+        letOrVar = RawTokenSyntax(missing: lastBindingKind!.tokenKind, text: lastBindingKind!.tokenText, arena: self.arena)
+      } else {
+        letOrVar = self.consumeAnyToken()
+      }
+
       let pattern = self.parseMatchingPattern(context: .bindingIntroducer)
       kind = .optional(letOrVar, pattern)
     }

Sources/SwiftParserDiagnostics/ParseDiagnosticsGenerator.swift

@@ -1232,6 +1232,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
+  }
+
   //==========================================================================//
   // IMPORTANT: If you are tempted to add a `visit` method here, please       //
   // insert it in alphabetical order above                                    //

Sources/SwiftParserDiagnostics/ParserDiagnosticMessages.swift

@@ -260,6 +260,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
 
@@ -527,6 +535,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
+        }
+        """
     )
   }