Emulate the Structure of Pattern Binding Conditions

The expression parser has to go out of its way to parse all the
way down to primary expressions before realizing that the expression
pattern it was after isn't actually an expression pattern. This involves
setting a bit of ambient state, that we have to plumb down expression parsing.

This is pretty gross, but it emulates what the legacy parser was doing here.

Fixes #724

rdar://99669036

Author: CodaFi

Sources/SwiftParser/Expressions.swift

@@ -70,7 +70,9 @@ extension Parser {
     // sequenced.
     var lastElement: RawExprSyntax
 
-    lastElement = self.parseSequenceExpressionElement(flavor, forDirective: forDirective)
+    lastElement = self.parseSequenceExpressionElement(flavor,
+                                                      forDirective: forDirective,
+                                                      inVarOrLet: inVarOrLet)
 
     var loopCondition = LoopProgressCondition()
     while loopCondition.evaluate(currentToken) {
@@ -101,7 +103,9 @@ extension Parser {
         lastElement = RawExprSyntax(RawMissingExprSyntax(arena: self.arena))
         break
       } else {
-        lastElement = self.parseSequenceExpressionElement(flavor, forDirective: forDirective)
+        lastElement = self.parseSequenceExpressionElement(flavor,
+                                                          forDirective: forDirective,
+                                                          inVarOrLet: inVarOrLet)
       }
     }
 
@@ -153,7 +157,7 @@ extension Parser {
     case .infixQuestionMark:
       // Save the '?'.
       let question = self.eat(.infixQuestionMark)
-      let firstChoice = self.parseSequenceExpression(flavor)
+      let firstChoice = self.parseSequenceExpression(flavor, inVarOrLet: inVarOrLet)
       // Make sure there's a matching ':' after the middle expr.
       let (unexpectedBeforeColon, colon) = self.expect(.colon)
 
@@ -250,11 +254,13 @@ extension Parser {
   @_spi(RawSyntax)
   public mutating func parseSequenceExpressionElement(
     _ flavor: ExprFlavor,
-    forDirective: Bool = false
+    forDirective: Bool = false,
+    inVarOrLet: Bool = false
   ) -> RawExprSyntax {
     if self.currentToken.isContextualKeyword("await") {
       let awaitTok = self.consumeAnyToken()
-      let sub = self.parseSequenceExpressionElement(flavor)
+      let sub = self.parseSequenceExpressionElement(flavor,
+                                                    inVarOrLet: inVarOrLet)
       return RawExprSyntax(RawAwaitExprSyntax(
         awaitKeyword: awaitTok, expression: sub,
         arena: self.arena))
@@ -271,7 +277,9 @@ extension Parser {
     }
 
     guard self.at(.tryKeyword) else {
-      return self.parseUnaryExpression(flavor, forDirective: forDirective)
+      return self.parseUnaryExpression(flavor,
+                                       forDirective: forDirective,
+                                       inVarOrLet: inVarOrLet)
     }
 
     let tryKeyword = self.eat(.tryKeyword)
@@ -282,7 +290,8 @@ extension Parser {
       mark = nil
     }
 
-    let expression = self.parseSequenceExpressionElement(flavor)
+    let expression = self.parseSequenceExpressionElement(flavor,
+                                                         inVarOrLet: inVarOrLet)
     return RawExprSyntax(RawTryExprSyntax(
       tryKeyword: tryKeyword,
       questionOrExclamationMark: mark,
@@ -302,31 +311,32 @@ extension Parser {
   @_spi(RawSyntax)
   public mutating func parseUnaryExpression(
     _ flavor: ExprFlavor,
-    forDirective: Bool = false
+    forDirective: Bool = false,
+    inVarOrLet: Bool = false
   ) -> RawExprSyntax {
     // First check to see if we have the start of a regex literal `/.../`.
     //    tryLexRegexLiteral(/*forUnappliedOperator*/ false)
     switch self.currentToken.tokenKind {
     case .prefixAmpersand:
       let amp = self.eat(.prefixAmpersand)
-      let expr = self.parseUnaryExpression(flavor)
+      let expr = self.parseUnaryExpression(flavor, forDirective: forDirective, inVarOrLet: inVarOrLet)
       return RawExprSyntax(RawInOutExprSyntax(
         ampersand: amp, expression: RawExprSyntax(expr),
         arena: self.arena))
 
     case .backslash:
-      return RawExprSyntax(self.parseKeyPathExpression(forDirective: forDirective))
+      return RawExprSyntax(self.parseKeyPathExpression(forDirective: forDirective, inVarOrLet: inVarOrLet))
 
     case .prefixOperator:
       let op = self.eat(.prefixOperator)
-      let postfix = self.parseUnaryExpression(flavor, forDirective: forDirective)
+      let postfix = self.parseUnaryExpression(flavor, forDirective: forDirective, inVarOrLet: inVarOrLet)
       return RawExprSyntax(RawPrefixOperatorExprSyntax(
         operatorToken: op, postfixExpression: postfix,
         arena: self.arena))
 
     default:
       // If the next token is not an operator, just parse this as expr-postfix.
-      return self.parsePostfixExpression(flavor, forDirective: forDirective)
+      return self.parsePostfixExpression(flavor, forDirective: forDirective, inVarOrLet: inVarOrLet)
     }
   }
 
@@ -347,9 +357,10 @@ extension Parser {
   @_spi(RawSyntax)
   public mutating func parsePostfixExpression(
     _ flavor: ExprFlavor,
-    forDirective: Bool
+    forDirective: Bool,
+    inVarOrLet: Bool
   ) -> RawExprSyntax {
-    let head = self.parsePrimaryExpression()
+    let head = self.parsePrimaryExpression(inVarOrLet: inVarOrLet)
     guard !head.is(RawMissingExprSyntax.self) else {
       return head
     }
@@ -631,7 +642,7 @@ extension Parser {
   ///     key-path-postfixes → key-path-postfix key-path-postfixes?
   ///     key-path-postfix → '?' | '!' | 'self' | '[' function-call-argument-list ']'
   @_spi(RawSyntax)
-  public mutating func parseKeyPathExpression(forDirective: Bool) -> RawKeyPathExprSyntax {
+  public mutating func parseKeyPathExpression(forDirective: Bool, inVarOrLet: Bool) -> RawKeyPathExprSyntax {
     // Consume '\'.
     let backslash = self.eat(.backslash)
 
@@ -642,7 +653,7 @@ extension Parser {
     // the token is a operator starts with '.', or the following token is '['.
     let root: RawExprSyntax?
     if !self.currentToken.starts(with: ".") {
-      root = self.parsePostfixExpression(.basic, forDirective: forDirective)
+      root = self.parsePostfixExpression(.basic, forDirective: forDirective, inVarOrLet: inVarOrLet)
     } else {
       root = nil
     }
@@ -689,7 +700,7 @@ extension Parser {
   ///     primary-expression → selector-expression
   ///     primary-expression → key-path-string-expression
   @_spi(RawSyntax)
-  public mutating func parsePrimaryExpression() -> RawExprSyntax {
+  public mutating func parsePrimaryExpression(inVarOrLet: Bool) -> RawExprSyntax {
     switch self.currentToken.tokenKind {
     case .integerLiteral:
       let digits = self.eat(.integerLiteral)
@@ -741,6 +752,16 @@ extension Parser {
       let tok = self.eat(.__dso_handle__Keyword)
       return RawExprSyntax(RawPoundDsohandleExprSyntax(poundDsohandle: tok, arena: self.arena))
     case .identifier, .selfKeyword:
+      // If we have "case let x." or "case let x(", we parse x as a normal
+      // name, not a binding, because it is the start of an enum pattern or
+      // call pattern.
+      if inVarOrLet && !self.lookahead().isNextTokenCallPattern() {
+        let identifier = self.parseAnyIdentifier()
+        let pattern = RawPatternSyntax(RawIdentifierPatternSyntax(
+          identifier: identifier, arena: self.arena))
+        return RawExprSyntax(RawUnresolvedPatternExprSyntax(pattern: pattern, arena: self.arena))
+      }
+
       // 'any' followed by another identifier is an existential type.
       if self.currentToken.isContextualKeyword("any"),
          self.peek().tokenKind == .identifier,
@@ -2102,4 +2123,15 @@ extension Parser.Lookahead {
     }
     return true
   }
+
+  fileprivate func isNextTokenCallPattern() -> Bool {
+    switch self.peek().tokenKind {
+    case .period,
+        .prefixPeriod,
+        .leftParen:
+      return true
+    default:
+      return false
+    }
+  }
 }

Sources/SwiftParser/Patterns.swift

@@ -163,7 +163,17 @@ extension Parser {
       // matching-pattern ::= expr
       // Fall back to expression parsing for ambiguous forms. Name lookup will
       // disambiguate.
-      let expr = RawExprSyntax(self.parseSequenceExpression(.basic, inVarOrLet: true))
+      let patternSyntax = self.parseSequenceExpression(.basic, inVarOrLet: true)
+      if let pat = patternSyntax.as(RawUnresolvedPatternExprSyntax.self) {
+        // The most common case here is to parse something that was a lexically
+        // obvious pattern, which will come back wrapped in an immediate
+        // RawUnresolvedPatternExprSyntax.
+        //
+        // FIXME: This is pretty gross. Let's find a way to disambiguate let
+        // binding patterns much earlier.
+        return RawPatternSyntax(pat.pattern)
+      }
+      let expr = RawExprSyntax(patternSyntax)
       return RawPatternSyntax(RawExpressionPatternSyntax(expression: expr, arena: self.arena))
     }
   }

Sources/SwiftParser/Statements.swift

@@ -217,7 +217,7 @@ extension Parser {
 
     // Parse the basic expression case.  If we have a leading let/var/case
     // keyword or an assignment, then we know this is a binding.
-    if !self.at(.letKeyword) && !self.at(.varKeyword) && !self.at(.caseKeyword) {
+    guard self.at(.letKeyword) || self.at(.varKeyword) || self.at(.caseKeyword) 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

Tests/SwiftParserTest/Statements.swift

@@ -4,6 +4,22 @@ import XCTest
 
 final class StatementTests: XCTestCase {
   func testIf() {
+    AssertParse("""
+                if let baz {}
+                """,
+                substructure: Syntax(IfStmtSyntax(ifKeyword: .ifKeyword(),
+                                                  conditions: ConditionElementListSyntax([
+                                                    ConditionElementSyntax(condition: Syntax(OptionalBindingConditionSyntax(
+                                                      letOrVarKeyword: .letKeyword(),
+                                                      pattern: PatternSyntax(IdentifierPatternSyntax(identifier: .identifier("baz"))),
+                                                      typeAnnotation: nil,
+                                                      initializer: nil)), trailingComma: nil)
+                                                  ]),
+                                                  body: .init(leftBrace: .leftBraceToken(),
+                                                              statements: .init([]),
+                                                              rightBrace: .rightBraceToken()),
+                                                  elseKeyword: nil, elseBody: nil)))
+
     AssertParse("if let x { }")
 
     AssertParse(