Parse method and initializer keypaths.

Author: amritpan

Sources/SwiftParser/Expressions.swift

@@ -1103,8 +1103,48 @@ extension Parser {
         continue
       }
 
-      // Check for a .name or .1 suffix.
+      // Check for a .name, .1, .name(), .name("Kiwi"), .name(fruit:),
+      // .name(_:), .name(fruit: "Kiwi) suffix.
       if self.at(.period) {
+        // Parse as a keypath method if fully applied.
+        if self.experimentalFeatures.contains(.keypathWithMethodMembers)
+          && self.withLookahead({ $0.isAppliedKeyPathMethod() })
+        {
+          let (unexpectedPeriod, period, declName, _) = parseDottedExpressionSuffix(
+            previousNode: components.last?.raw ?? rootType?.raw ?? backslash.raw
+          )
+          let leftParen = self.consumeAnyToken()
+          var args: [RawLabeledExprSyntax] = []
+          if !self.at(.rightParen) {
+            args = self.parseArgumentListElements(
+              pattern: pattern,
+              allowTrailingComma: true
+            )
+          }
+          let (unexpectedBeforeRParen, rightParen) = self.expect(.rightParen)
+          components.append(
+            RawKeyPathComponentSyntax(
+              unexpectedPeriod,
+              period: period,
+              component: .method(
+                RawKeyPathMethodComponentSyntax(
+                  declName: declName,
+                  leftParen: leftParen,
+                  arguments: RawLabeledExprListSyntax(
+                    elements: args,
+                    arena: self.arena
+                  ),
+                  unexpectedBeforeRParen,
+                  rightParen: rightParen,
+                  arena: self.arena
+                )
+              ),
+              arena: self.arena
+            )
+          )
+          continue
+        }
+        // Else, parse as a property.
         let (unexpectedPeriod, period, declName, generics) = parseDottedExpressionSuffix(
           previousNode: components.last?.raw ?? rootType?.raw ?? backslash.raw
         )
@@ -1128,7 +1168,6 @@ extension Parser {
       // No more postfix expressions.
       break
     }
-
     return RawKeyPathExprSyntax(
       unexpectedBeforeBackslash,
       backslash: backslash,
@@ -2017,6 +2056,37 @@ extension Parser {
 }
 
 extension Parser.Lookahead {
+  /// Check if the keypath method is applied, and not partially applied which should be parsed as a key path property.
+  mutating func isAppliedKeyPathMethod() -> Bool {
+    var lookahead = self.lookahead()
+    var hasLParen = false, hasRParen = false
+
+    while true {
+      let token = lookahead.peek().rawTokenKind
+      if token == .endOfFile || lookahead.atStartOfLine {
+        break
+      }
+      if token == .leftParen {
+        hasLParen = true
+      }
+      if token == .colon {
+        lookahead.consumeAnyToken()
+        // If there's a colon followed by a right parenthesis, it is
+        // a partial application and should be parsed as a property.
+        if lookahead.peek().rawTokenKind == .rightParen {
+          return false
+        }
+      }
+      if token == .rightParen {
+        hasRParen = true
+      }
+      lookahead.consumeAnyToken()
+    }
+    // If parentheses exist with no partial application pattern,
+    // parse as a key path method.
+    return hasLParen && hasRParen ? true : false
+  }
+
   mutating func atStartOfLabelledTrailingClosure() -> Bool {
     // Fast path: the next two tokens must be a label and a colon.
     // But 'default:' is ambiguous with switch cases and we disallow it