Add supporting code.

Author: amritpan

Diff for: Sources/SwiftParser/generated/ExperimentalFeatures.swift

@@ -48,6 +48,9 @@ extension Parser.ExperimentalFeatures {
   /// Whether to enable the parsing of @abi attribute.
   public static let abiAttribute = Self (rawValue: 1 << 7)
 
+  /// Whether to enable the parsing of keypaths with method members.
+  public static let keypathWithMethodMembers = Self (rawValue: 1 << 8)
+
   /// Creates a new value representing the experimental feature with the
   /// given name, or returns nil if the name is not recognized.
   public init?(name: String) {
@@ -68,6 +71,8 @@ extension Parser.ExperimentalFeatures {
       self = .valueGenerics
     case "ABIAttribute":
       self = .abiAttribute
+    case "KeypathWithMethodMembers":
+      self = .keypathWithMethodMembers
     default:
       return nil
     }

Diff for: Sources/SwiftParserDiagnostics/generated/ChildNameForDiagnostics.swift

@@ -206,6 +206,8 @@ private func childNameForDiagnostics(_ keyPath: AnyKeyPath) -> String? {
     return "generic where clause"
   case \KeyPathExprSyntax.root:
     return "root"
+  case \KeyPathMethodComponentSyntax.arguments:
+    return "arguments"
   case \KeyPathSubscriptComponentSyntax.arguments:
     return "arguments"
   case \LabeledExprSyntax.label:

Diff for: Sources/SwiftParserDiagnostics/generated/SyntaxKindNameForDiagnostics.swift

@@ -249,6 +249,8 @@ extension SyntaxKind {
       return "key path component"
     case .keyPathExpr:
       return "key path"
+    case .keyPathMethodComponent:
+      return "key path method component"
     case .keyPathOptionalComponent:
       return "key path optional component"
     case .keyPathPropertyComponent:

Diff for: Sources/SwiftSyntax/generated/ChildNameForKeyPath.swift

@@ -1951,6 +1951,24 @@ public func childName(_ keyPath: AnyKeyPath) -> String? {
     return "components"
   case \KeyPathExprSyntax.unexpectedAfterComponents:
     return "unexpectedAfterComponents"
+  case \KeyPathMethodComponentSyntax.unexpectedBeforeDeclName:
+    return "unexpectedBeforeDeclName"
+  case \KeyPathMethodComponentSyntax.declName:
+    return "declName"
+  case \KeyPathMethodComponentSyntax.unexpectedBetweenDeclNameAndLeftParen:
+    return "unexpectedBetweenDeclNameAndLeftParen"
+  case \KeyPathMethodComponentSyntax.leftParen:
+    return "leftParen"
+  case \KeyPathMethodComponentSyntax.unexpectedBetweenLeftParenAndArguments:
+    return "unexpectedBetweenLeftParenAndArguments"
+  case \KeyPathMethodComponentSyntax.arguments:
+    return "arguments"
+  case \KeyPathMethodComponentSyntax.unexpectedBetweenArgumentsAndRightParen:
+    return "unexpectedBetweenArgumentsAndRightParen"
+  case \KeyPathMethodComponentSyntax.rightParen:
+    return "rightParen"
+  case \KeyPathMethodComponentSyntax.unexpectedAfterRightParen:
+    return "unexpectedAfterRightParen"
   case \KeyPathOptionalComponentSyntax.unexpectedBeforeQuestionOrExclamationMark:
     return "unexpectedBeforeQuestionOrExclamationMark"
   case \KeyPathOptionalComponentSyntax.questionOrExclamationMark:

Diff for: Sources/SwiftSyntax/generated/SyntaxAnyVisitor.swift

@@ -1324,6 +1324,16 @@ open class SyntaxAnyVisitor: SyntaxVisitor {
     visitAnyPost(node._syntaxNode)
   }
 
+  @_spi(ExperimentalLanguageFeatures)
+  override open func visit(_ node: KeyPathMethodComponentSyntax) -> SyntaxVisitorContinueKind {
+    return visitAny(node._syntaxNode)
+  }
+
+  @_spi(ExperimentalLanguageFeatures)
+  override open func visitPost(_ node: KeyPathMethodComponentSyntax) {
+    visitAnyPost(node._syntaxNode)
+  }
+
   override open func visit(_ node: KeyPathOptionalComponentSyntax) -> SyntaxVisitorContinueKind {
     return visitAny(node._syntaxNode)
   }

Diff for: Sources/SwiftSyntax/generated/SyntaxBaseNodes.swift

@@ -1676,6 +1676,7 @@ extension Syntax {
       .node(KeyPathComponentListSyntax.self),
       .node(KeyPathComponentSyntax.self),
       .node(KeyPathExprSyntax.self),
+      .node(KeyPathMethodComponentSyntax.self),
       .node(KeyPathOptionalComponentSyntax.self),
       .node(KeyPathPropertyComponentSyntax.self),
       .node(KeyPathSubscriptComponentSyntax.self),

Diff for: Sources/SwiftSyntax/generated/SyntaxEnum.swift

@@ -178,6 +178,8 @@ public enum SyntaxEnum: Sendable {
   case keyPathComponentList(KeyPathComponentListSyntax)
   case keyPathComponent(KeyPathComponentSyntax)
   case keyPathExpr(KeyPathExprSyntax)
+  @_spi(ExperimentalLanguageFeatures)
+  case keyPathMethodComponent(KeyPathMethodComponentSyntax)
   case keyPathOptionalComponent(KeyPathOptionalComponentSyntax)
   case keyPathPropertyComponent(KeyPathPropertyComponentSyntax)
   case keyPathSubscriptComponent(KeyPathSubscriptComponentSyntax)
@@ -638,6 +640,8 @@ extension Syntax {
       return .keyPathComponent(KeyPathComponentSyntax(self)!)
     case .keyPathExpr:
       return .keyPathExpr(KeyPathExprSyntax(self)!)
+    case .keyPathMethodComponent:
+      return .keyPathMethodComponent(KeyPathMethodComponentSyntax(self)!)
     case .keyPathOptionalComponent:
       return .keyPathOptionalComponent(KeyPathOptionalComponentSyntax(self)!)
     case .keyPathPropertyComponent:

Diff for: Sources/SwiftSyntax/generated/SyntaxKind.swift

@@ -178,6 +178,8 @@ public enum SyntaxKind: Sendable {
   case keyPathComponentList
   case keyPathComponent
   case keyPathExpr
+  @_spi(ExperimentalLanguageFeatures)
+  case keyPathMethodComponent
   case keyPathOptionalComponent
   case keyPathPropertyComponent
   case keyPathSubscriptComponent
@@ -763,6 +765,8 @@ public enum SyntaxKind: Sendable {
       return KeyPathComponentSyntax.self
     case .keyPathExpr:
       return KeyPathExprSyntax.self
+    case .keyPathMethodComponent:
+      return KeyPathMethodComponentSyntax.self
     case .keyPathOptionalComponent:
       return KeyPathOptionalComponentSyntax.self
     case .keyPathPropertyComponent:

Diff for: Sources/SwiftSyntax/generated/SyntaxRewriter.swift

@@ -1203,6 +1203,14 @@ open class SyntaxRewriter {
     return ExprSyntax(KeyPathExprSyntax(unsafeCasting: visitChildren(node._syntaxNode)))
   }
 
+  /// Visit a `KeyPathMethodComponentSyntax`.
+  ///   - Parameter node: the node that is being visited
+  ///   - Returns: the rewritten node
+  @_spi(ExperimentalLanguageFeatures)
+  open func visit(_ node: KeyPathMethodComponentSyntax) -> KeyPathMethodComponentSyntax {
+    return KeyPathMethodComponentSyntax(unsafeCasting: visitChildren(node._syntaxNode))
+  }
+
   /// Visit a ``KeyPathOptionalComponentSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
@@ -2964,6 +2972,11 @@ open class SyntaxRewriter {
     Syntax(visit(KeyPathExprSyntax(unsafeCasting: node)))
   }
 
+  @inline(never)
+  private func visitKeyPathMethodComponentSyntaxImpl(_ node: Syntax) -> Syntax {
+    Syntax(visit(KeyPathMethodComponentSyntax(unsafeCasting: node)))
+  }
+
   @inline(never)
   private func visitKeyPathOptionalComponentSyntaxImpl(_ node: Syntax) -> Syntax {
     Syntax(visit(KeyPathOptionalComponentSyntax(unsafeCasting: node)))
@@ -3971,6 +3984,8 @@ open class SyntaxRewriter {
       return self.visitKeyPathComponentSyntaxImpl(_:)
     case .keyPathExpr:
       return self.visitKeyPathExprSyntaxImpl(_:)
+    case .keyPathMethodComponent:
+      return self.visitKeyPathMethodComponentSyntaxImpl(_:)
     case .keyPathOptionalComponent:
       return self.visitKeyPathOptionalComponentSyntaxImpl(_:)
     case .keyPathPropertyComponent:
@@ -4561,6 +4576,8 @@ open class SyntaxRewriter {
       return visitKeyPathComponentSyntaxImpl(node)
     case .keyPathExpr:
       return visitKeyPathExprSyntaxImpl(node)
+    case .keyPathMethodComponent:
+      return visitKeyPathMethodComponentSyntaxImpl(node)
     case .keyPathOptionalComponent:
       return visitKeyPathOptionalComponentSyntaxImpl(node)
     case .keyPathPropertyComponent:

Diff for: Sources/SwiftSyntax/generated/SyntaxVisitor.swift

@@ -1930,6 +1930,20 @@ open class SyntaxVisitor {
   open func visitPost(_ node: KeyPathExprSyntax) {
   }
 
+  /// Visiting `KeyPathMethodComponentSyntax` specifically.
+  ///   - Parameter node: the node we are visiting.
+  ///   - Returns: how should we continue visiting.
+  @_spi(ExperimentalLanguageFeatures)
+  open func visit(_ node: KeyPathMethodComponentSyntax) -> SyntaxVisitorContinueKind {
+    return .visitChildren
+  }
+
+  /// The function called after visiting `KeyPathMethodComponentSyntax` and its descendants.
+  ///   - node: the node we just finished visiting.
+  @_spi(ExperimentalLanguageFeatures)
+  open func visitPost(_ node: KeyPathMethodComponentSyntax) {
+  }
+
   /// Visiting ``KeyPathOptionalComponentSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
@@ -4811,6 +4825,14 @@ open class SyntaxVisitor {
     visitPost(KeyPathExprSyntax(unsafeCasting: node))
   }
 
+  @inline(never)
+  private func visitKeyPathMethodComponentSyntaxImpl(_ node: Syntax) {
+    if visit(KeyPathMethodComponentSyntax(unsafeCasting: node)) == .visitChildren {
+      visitChildren(node)
+    }
+    visitPost(KeyPathMethodComponentSyntax(unsafeCasting: node))
+  }
+
   @inline(never)
   private func visitKeyPathOptionalComponentSyntaxImpl(_ node: Syntax) {
     if visit(KeyPathOptionalComponentSyntax(unsafeCasting: node)) == .visitChildren {
@@ -6217,6 +6239,8 @@ open class SyntaxVisitor {
       return self.visitKeyPathComponentSyntaxImpl(_:)
     case .keyPathExpr:
       return self.visitKeyPathExprSyntaxImpl(_:)
+    case .keyPathMethodComponent:
+      return self.visitKeyPathMethodComponentSyntaxImpl(_:)
     case .keyPathOptionalComponent:
       return self.visitKeyPathOptionalComponentSyntaxImpl(_:)
     case .keyPathPropertyComponent:
@@ -6807,6 +6831,8 @@ open class SyntaxVisitor {
       self.visitKeyPathComponentSyntaxImpl(node)
     case .keyPathExpr:
       self.visitKeyPathExprSyntaxImpl(node)
+    case .keyPathMethodComponent:
+      self.visitKeyPathMethodComponentSyntaxImpl(node)
     case .keyPathOptionalComponent:
       self.visitKeyPathOptionalComponentSyntaxImpl(node)
     case .keyPathPropertyComponent:

Diff for: Sources/SwiftSyntax/generated/raw/RawSyntaxNodesJKLMN.swift

@@ -66,17 +66,22 @@ public struct RawKeyPathComponentListSyntax: RawSyntaxNodeProtocol {
 public struct RawKeyPathComponentSyntax: RawSyntaxNodeProtocol {
   public enum Component: RawSyntaxNodeProtocol {
     case property(RawKeyPathPropertyComponentSyntax)
+    /// - Note: Requires experimental feature `keypathWithMethodMembers`.
+    @_spi(ExperimentalLanguageFeatures)
+    case method(RawKeyPathMethodComponentSyntax)
     case `subscript`(RawKeyPathSubscriptComponentSyntax)
     case optional(RawKeyPathOptionalComponentSyntax)
 
     public static func isKindOf(_ raw: RawSyntax) -> Bool {
-      RawKeyPathPropertyComponentSyntax.isKindOf(raw) || RawKeyPathSubscriptComponentSyntax.isKindOf(raw) || RawKeyPathOptionalComponentSyntax.isKindOf(raw)
+      RawKeyPathPropertyComponentSyntax.isKindOf(raw) || RawKeyPathMethodComponentSyntax.isKindOf(raw) || RawKeyPathSubscriptComponentSyntax.isKindOf(raw) || RawKeyPathOptionalComponentSyntax.isKindOf(raw)
     }
 
     public var raw: RawSyntax {
       switch self {
       case .property(let node):
         return node.raw
+      case .method(let node):
+        return node.raw
       case .subscript(let node):
         return node.raw
       case .optional(let node):
@@ -87,6 +92,8 @@ public struct RawKeyPathComponentSyntax: RawSyntaxNodeProtocol {
     public init?(_ node: __shared some RawSyntaxNodeProtocol) {
       if let node = node.as(RawKeyPathPropertyComponentSyntax.self) {
         self = .property(node)
+      } else if let node = node.as(RawKeyPathMethodComponentSyntax.self) {
+        self = .method(node)
       } else if let node = node.as(RawKeyPathSubscriptComponentSyntax.self) {
         self = .subscript(node)
       } else if let node = node.as(RawKeyPathOptionalComponentSyntax.self) {
@@ -247,6 +254,101 @@ public struct RawKeyPathExprSyntax: RawExprSyntaxNodeProtocol {
   }
 }
 
+@_spi(ExperimentalLanguageFeatures)
+@_spi(RawSyntax)
+public struct RawKeyPathMethodComponentSyntax: RawSyntaxNodeProtocol {
+  @_spi(RawSyntax)
+  public var layoutView: RawSyntaxLayoutView {
+    return raw.layoutView!
+  }
+
+  public static func isKindOf(_ raw: RawSyntax) -> Bool {
+    return raw.kind == .keyPathMethodComponent
+  }
+
+  public var raw: RawSyntax
+
+  init(raw: RawSyntax) {
+    precondition(Self.isKindOf(raw))
+    self.raw = raw
+  }
+
+  private init(unchecked raw: RawSyntax) {
+    self.raw = raw
+  }
+
+  public init?(_ other: some RawSyntaxNodeProtocol) {
+    guard Self.isKindOf(other.raw) else {
+      return nil
+    }
+    self.init(unchecked: other.raw)
+  }
+
+  public init(
+    _ unexpectedBeforeDeclName: RawUnexpectedNodesSyntax? = nil,
+    declName: RawDeclReferenceExprSyntax,
+    _ unexpectedBetweenDeclNameAndLeftParen: RawUnexpectedNodesSyntax? = nil,
+    leftParen: RawTokenSyntax,
+    _ unexpectedBetweenLeftParenAndArguments: RawUnexpectedNodesSyntax? = nil,
+    arguments: RawLabeledExprListSyntax,
+    _ unexpectedBetweenArgumentsAndRightParen: RawUnexpectedNodesSyntax? = nil,
+    rightParen: RawTokenSyntax,
+    _ unexpectedAfterRightParen: RawUnexpectedNodesSyntax? = nil,
+    arena: __shared RawSyntaxArena
+  ) {
+    let raw = RawSyntax.makeLayout(
+      kind: .keyPathMethodComponent, uninitializedCount: 9, arena: arena) { layout in
+      layout.initialize(repeating: nil)
+      layout[0] = unexpectedBeforeDeclName?.raw
+      layout[1] = declName.raw
+      layout[2] = unexpectedBetweenDeclNameAndLeftParen?.raw
+      layout[3] = leftParen.raw
+      layout[4] = unexpectedBetweenLeftParenAndArguments?.raw
+      layout[5] = arguments.raw
+      layout[6] = unexpectedBetweenArgumentsAndRightParen?.raw
+      layout[7] = rightParen.raw
+      layout[8] = unexpectedAfterRightParen?.raw
+    }
+    self.init(unchecked: raw)
+  }
+
+  public var unexpectedBeforeDeclName: RawUnexpectedNodesSyntax? {
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
+  }
+
+  public var declName: RawDeclReferenceExprSyntax {
+    layoutView.children[1].map(RawDeclReferenceExprSyntax.init(raw:))!
+  }
+
+  public var unexpectedBetweenDeclNameAndLeftParen: RawUnexpectedNodesSyntax? {
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
+  }
+
+  public var leftParen: RawTokenSyntax {
+    layoutView.children[3].map(RawTokenSyntax.init(raw:))!
+  }
+
+  public var unexpectedBetweenLeftParenAndArguments: RawUnexpectedNodesSyntax? {
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
+  }
+
+  public var arguments: RawLabeledExprListSyntax {
+    layoutView.children[5].map(RawLabeledExprListSyntax.init(raw:))!
+  }
+
+  public var unexpectedBetweenArgumentsAndRightParen: RawUnexpectedNodesSyntax? {
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
+  }
+
+  public var rightParen: RawTokenSyntax {
+    layoutView.children[7].map(RawTokenSyntax.init(raw:))!
+  }
+
+  public var unexpectedAfterRightParen: RawUnexpectedNodesSyntax? {
+    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:))
+  }
+}
+
 @_spi(RawSyntax)
 public struct RawKeyPathOptionalComponentSyntax: RawSyntaxNodeProtocol {
   @_spi(RawSyntax)

Diff for: Sources/SwiftSyntax/generated/raw/RawSyntaxValidation.swift

@@ -1822,6 +1822,18 @@ func validateLayout(layout: RawSyntaxBuffer, as kind: SyntaxKind) {
     assertNoError(kind, 5, verify(layout[5], as: RawKeyPathComponentListSyntax.self))
     assertNoError(kind, 6, verify(layout[6], as: RawUnexpectedNodesSyntax?.self))
   }
+  func validateKeyPathMethodComponentSyntax(kind: SyntaxKind, layout: RawSyntaxBuffer) {
+    assert(layout.count == 9)
+    assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self))
+    assertNoError(kind, 1, verify(layout[1], as: RawDeclReferenceExprSyntax.self))
+    assertNoError(kind, 2, verify(layout[2], as: RawUnexpectedNodesSyntax?.self))
+    assertNoError(kind, 3, verify(layout[3], as: RawTokenSyntax.self, tokenChoices: [.tokenKind(.leftParen)]))
+    assertNoError(kind, 4, verify(layout[4], as: RawUnexpectedNodesSyntax?.self))
+    assertNoError(kind, 5, verify(layout[5], as: RawLabeledExprListSyntax.self))
+    assertNoError(kind, 6, verify(layout[6], as: RawUnexpectedNodesSyntax?.self))
+    assertNoError(kind, 7, verify(layout[7], as: RawTokenSyntax.self, tokenChoices: [.tokenKind(.rightParen)]))
+    assertNoError(kind, 8, verify(layout[8], as: RawUnexpectedNodesSyntax?.self))
+  }
   func validateKeyPathOptionalComponentSyntax(kind: SyntaxKind, layout: RawSyntaxBuffer) {
     assert(layout.count == 3)
     assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self))
@@ -3462,6 +3474,8 @@ func validateLayout(layout: RawSyntaxBuffer, as kind: SyntaxKind) {
     validateKeyPathComponentSyntax(kind: kind, layout: layout)
   case .keyPathExpr:
     validateKeyPathExprSyntax(kind: kind, layout: layout)
+  case .keyPathMethodComponent:
+    validateKeyPathMethodComponentSyntax(kind: kind, layout: layout)
   case .keyPathOptionalComponent:
     validateKeyPathOptionalComponentSyntax(kind: kind, layout: layout)
   case .keyPathPropertyComponent: