Keep Track of Whether We're Under a Let or a Var

The legacy parser maintains a stack of contexts that determine whether a matching pattern is being parsed, and whether a let or var is the introducer. This turns on and off a particular production in expression parsing that helps to meld patterns like

`Optional<String>.none`

into shape depending on whether it comes after the keyword "case" or after "let" or "var".

Author: CodaFi

Sources/SwiftParser/Expressions.swift

@@ -34,15 +34,26 @@ extension Parser {
   }
 
   public enum PatternContext {
+    /// There is no ambient pattern context.
     case none
+    /// We're parsing a matching pattern that is not introduced via `let` or `var`.
+    ///
+    /// In this context, identifiers are references to the enclosing scopes, not a variable binding.
+    ///
+    /// ```
+    /// case x.y <- 'x' must refer to some 'x' defined in another scope, it cannot be e.g. an enum type.
+    /// ```
     case matching
-    case `var`
-    case `let`
-    case implicitlyImmutable
+    /// We're parsing a matching pattern that is introduced via `let` or `var`.
+    ///
+    /// ```
+    /// case let x.y <- 'x' must refer to the base of some member access, y must refer to some pattern-compatible identfier
+    /// ```
+    case letOrVar
 
     var admitsBinding: Bool {
       switch self {
-      case .implicitlyImmutable, .var, .let:
+      case .letOrVar:
         return true
       case .none, .matching:
         return false
@@ -65,8 +76,8 @@ extension Parser {
     //
     // Only do this if we're parsing a pattern, to improve QoI on malformed
     // expressions followed by (e.g.) let/var decls.
-    if self.at(anyIn: MatchingPatternStart.self) != nil {
-      let pattern = self.parseMatchingPattern()
+    if pattern != .none, self.at(anyIn: MatchingPatternStart.self) != nil {
+      let pattern = self.parseMatchingPattern(context: .matching)
       return RawExprSyntax(RawUnresolvedPatternExprSyntax(pattern: pattern, arena: self.arena))
     }
     return RawExprSyntax(self.parseSequenceExpression(flavor, pattern: pattern))
@@ -261,9 +272,9 @@ extension Parser {
 
     case (.equal, let handle)?:
       switch pattern {
-      case .matching, .let, .var:
+      case .matching, .letOrVar:
         return nil
-      case .none, .implicitlyImmutable:
+      case .none:
         let eq = self.eat(handle)
         let op = RawAssignmentExprSyntax(
           assignToken: eq,

Sources/SwiftParser/Patterns.swift

@@ -72,7 +72,6 @@ extension Parser {
         case .varKeyword: return .varKeyword
         }
       }
-
     }
 
     switch self.at(anyIn: ExpectedTokens.self) {
@@ -171,13 +170,13 @@ extension Parser {
 extension Parser {
   /// Parse a pattern that appears immediately under syntax for conditionals like
   /// for-in loops and guard clauses.
-  mutating func parseMatchingPattern() -> RawPatternSyntax {
+  mutating func parseMatchingPattern(context: PatternContext) -> RawPatternSyntax {
     // Parse productions that can only be patterns.
     switch self.at(anyIn: MatchingPatternStart.self) {
     case (.varKeyword, let handle)?,
-      (.letKeyword, let handle)?:
+         (.letKeyword, let handle)?:
       let letOrVar = self.eat(handle)
-      let value = self.parseMatchingPattern()
+      let value = self.parseMatchingPattern(context: .letOrVar)
       return RawPatternSyntax(RawValueBindingPatternSyntax(
         letOrVarKeyword: letOrVar, valuePattern: value, arena: self.arena))
     case (.isKeyword, let handle)?:
@@ -192,7 +191,7 @@ extension Parser {
       // matching-pattern ::= expr
       // Fall back to expression parsing for ambiguous forms. Name lookup will
       // disambiguate.
-      let patternSyntax = self.parseSequenceExpression(.basic, pattern: .matching)
+      let patternSyntax = self.parseSequenceExpression(.basic, pattern: context)
       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

Sources/SwiftParser/Statements.swift

@@ -261,11 +261,11 @@ extension Parser {
 
     let kind: BindingKind
     if let caseKeyword = self.consume(if: .caseKeyword) {
-      let pattern = self.parseMatchingPattern()
+      let pattern = self.parseMatchingPattern(context: .matching)
       kind = .pattern(caseKeyword, pattern)
     } else {
       let letOrVar = self.consumeAnyToken()
-      let pattern = self.parseMatchingPattern()
+      let pattern = self.parseMatchingPattern(context: .letOrVar)
       kind = .optional(letOrVar, pattern)
     }
 
@@ -563,7 +563,7 @@ extension Parser {
     let pattern: RawPatternSyntax
     let type: RawTypeAnnotationSyntax?
     if caseKeyword != nil {
-      pattern = self.parseMatchingPattern()
+      pattern = self.parseMatchingPattern(context: .matching)
       // Now parse an optional type annotation.
       if let colon = self.consume(if: .colon) {
         let resultType = self.parseType()
@@ -827,7 +827,7 @@ extension Parser {
       flavor = .basic
     }
 
-    let pattern = self.parseMatchingPattern()
+    let pattern = self.parseMatchingPattern(context: .matching)
 
     // Parse the optional 'where' guard, with this particular pattern's bound
     // vars in scope.

Tests/SwiftParserTest/Statements.swift

@@ -288,4 +288,72 @@ final class StatementTests: XCTestCase {
       ))
     )
   }
+
+  func testCaseContext() {
+    AssertParse(
+      """
+      graphQLMap["clientMutationId"] as? #^SPECIALIZATION^#Swift.Optional<String?> ?? Swift.Optional<String?>.none
+      """,
+//      0: MemberTypeIdentifierSyntax children=4
+//        0: SimpleTypeIdentifierSyntax children=1
+//          0: identifier("Swift")
+//        1: period
+//        2: identifier("Optional")
+//        3: GenericArgumentClauseSyntax children=3
+//          0: leftAngle
+//          1: GenericArgumentListSyntax children=1
+//            0: GenericArgumentSyntax children=1
+//              0: OptionalTypeSyntax children=2
+//                0: SimpleTypeIdentifierSyntax children=1
+//                  0: identifier("String")
+//                1: postfixQuestionMark
+//          2: rightAngle
+    substructure: Syntax(MemberTypeIdentifierSyntax(
+      baseType: TypeSyntax(SimpleTypeIdentifierSyntax(
+        name: .identifier("Swift"),
+        genericArgumentClause: nil)),
+      period: .periodToken(),
+      name: .identifier("Optional"),
+      genericArgumentClause: GenericArgumentClauseSyntax(
+        leftAngleBracket: .leftAngleToken(),
+        arguments: GenericArgumentListSyntax([
+          GenericArgumentSyntax(
+            argumentType: TypeSyntax(OptionalTypeSyntax(
+              wrappedType: TypeSyntax(SimpleTypeIdentifierSyntax(
+                name: .identifier("String"),
+                genericArgumentClause: nil)),
+              questionMark: .postfixQuestionMarkToken())),
+            trailingComma: nil)
+        ]),
+        rightAngleBracket: .rightAngleToken()))),
+    substructureAfterMarker: "SPECIALIZATION")
+
+    AssertParse(
+      """
+      if case #^SPECIALIZATION^#Optional<Any>.none = object["anyCol"] { }
+      """,
+//      0: SpecializeExprSyntax children=2
+//        0: IdentifierExprSyntax children=1
+//          0: identifier("Optional")
+//        1: GenericArgumentClauseSyntax children=3
+//          0: leftAngle
+//          1: GenericArgumentListSyntax children=1
+//            0: GenericArgumentSyntax children=1
+//              0: SimpleTypeIdentifierSyntax children=1
+//                0: anyKeyword
+//          2: rightAngle
+//      1: period
+//      2: identifier("none")
+      substructure: Syntax(SpecializeExprSyntax(
+        expression: ExprSyntax(IdentifierExprSyntax(
+          identifier: .identifier("Optional"), declNameArguments: nil)),
+        genericArgumentClause: GenericArgumentClauseSyntax(
+          leftAngleBracket: .leftAngleToken(), arguments: GenericArgumentListSyntax([
+        GenericArgumentSyntax(
+          argumentType: TypeSyntax(SimpleTypeIdentifierSyntax(
+            name: .anyKeyword(), genericArgumentClause: nil)),
+          trailingComma: nil)
+      ]), rightAngleBracket: .rightAngleToken()))),
+      substructureAfterMarker: "SPECIALIZATION")
+  }
 }

Tests/SwiftParserTest/translated/InvalidTests.swift

@@ -273,10 +273,10 @@ final class InvalidTests: XCTestCase {
         DiagnosticSpec(locationMarker: "DIAG_12", message: "expected identifier in function"),
         DiagnosticSpec(locationMarker: "DIAG_12", message: "expected argument list in function declaration"),
         DiagnosticSpec(locationMarker: "DIAG_13", message: "unexpected text '()' in 'repeat' statement"),
-        DiagnosticSpec(locationMarker: "DIAG_14", message: "expected 'while' in 'repeat' statement"),
+        DiagnosticSpec(locationMarker: "DIAG_14", message: "expected 'while' and condition in 'repeat' statement"),
         // TODO: Old parser expected error on line 30: keyword 'for' cannot be used as an identifier here
         // TODO: Old parser expected note on line 30: if this name is unavoidable, use backticks to escape it, Fix-It replacements: 5 - 8 = '`for`'
-        DiagnosticSpec(locationMarker: "DIAG_15", message: "expected expression in pattern"),
+        DiagnosticSpec(locationMarker: "DIAG_15", message: "expected pattern in variable"),
         DiagnosticSpec(locationMarker: "DIAG_16", message: "expected pattern, 'in' and expression in 'for' statement"),
         DiagnosticSpec(locationMarker: "DIAG_16", message: "expected '{' in 'for' statement"),
         DiagnosticSpec(locationMarker: "DIAG_16", message: "unexpected text '= 2' before function"),