Add childrenKeyPaths

Author: ahoppen

Sources/SwiftSyntax/Syntax.swift

@@ -49,6 +49,10 @@ public struct Syntax: SyntaxProtocol, SyntaxHashable {
     self = syntax._syntaxNode
   }
 
+  public static var childrenKeyPaths: [AnyKeyPath] {
+    fatalError("Syntax is a base type and thus doesn't have statically known children")
+  }
+
   public func hash(into hasher: inout Hasher) {
     return data.nodeId.hash(into: &hasher)
   }
@@ -136,13 +140,28 @@ public protocol SyntaxProtocol: CustomStringConvertible,
   /// conversion is not possible.
   init?(_ syntaxNode: Syntax)
 
+  /// An array that maps children indicies to key paths that can be used to
+  /// access this child. Use cases for these are:
+  ///  - To name parent-child relationships of syntax nodes (e.g. to specify that
+  ///    the right brace of a CodeBlockItem should be put on a new line)
+  ///  - To get the static type of a child of a syntax node
+  ///
+  /// Technically, this should have type `PartialKeyPath<Self>` but we cannot do
+  /// that because then `SyntaxProtocol` would have a Self type requirement.
+  static var childrenKeyPaths: [AnyKeyPath] { get }
+
   /// Return a name with which the child at the given `index` can be referred to
   /// in diagnostics.
   /// Typically, you want to use `childNameInParent` on the child instead of
   /// calling this method on the parent.
   func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String?
 }
 
+public extension SyntaxProtocol {
+  /// Returns the value of the static `childrenKeyPaths` for this node's type.
+  var childrenKeyPaths: [AnyKeyPath] { return Self.childrenKeyPaths }
+}
+
 public extension SyntaxProtocol {
   /// If the parent has a dedicated "name for diagnostics" for this node, return it.
   /// Otherwise, return `nil`.

Sources/SwiftSyntax/SyntaxBaseNodes.swift.gyb

@@ -138,6 +138,15 @@ public struct ${node.name}: ${node.name}Protocol, SyntaxHashable {
     return Syntax(self).asProtocol(${node.name}Protocol.self)!
   }
 
+  public static var childrenKeyPaths: [AnyKeyPath] {
+    fatalError("${node.name} is a base type and thus doesn't have statically known children")
+  }
+
+  public var childrenKeyPaths: [AnyKeyPath] {
+    return Syntax(self).childrenKeyPaths
+  }
+
+
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     return Syntax(self).childNameForDiagnostics(index)
   }

Sources/SwiftSyntax/SyntaxCollections.swift.gyb

@@ -23,6 +23,10 @@ public protocol SyntaxCollection: SyntaxProtocol, Sequence {
   var count: Int { get }
 }
 
+public extension SyntaxCollection {
+  static var childrenKeyPaths: [AnyKeyPath] { [] }
+}
+
 % for node in SYNTAX_NODES:
 %   if node.collection_element:
 %     element_node = NODE_MAP.get(node.collection_element)

Sources/SwiftSyntax/SyntaxNodes.swift.gyb.template

@@ -172,6 +172,14 @@ public struct ${node.name}: ${base_type}Protocol, SyntaxHashable {
   }
 %     end
 
+  public static var childrenKeyPaths: [AnyKeyPath] {
+    [
+%     for (index, child) in enumerate(node.children):
+      \Self.${child.swift_name},
+%     end
+    ]
+  }
+
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
 %     for (index, child) in enumerate(node.children):

Sources/SwiftSyntax/SyntaxOtherNodes.swift

@@ -38,6 +38,8 @@ public struct UnknownSyntax: SyntaxProtocol, SyntaxHashable {
     self.init(data)
   }
 
+  public static var childrenKeyPaths: [AnyKeyPath] { [] }
+
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     return nil
   }
@@ -195,6 +197,8 @@ public struct TokenSyntax: SyntaxProtocol, SyntaxHashable {
     return raw.totalLength
   }
 
+  public static var childrenKeyPaths: [AnyKeyPath] { [] }
+
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     return nil
   }

Sources/SwiftSyntax/gyb_generated/SyntaxBaseNodes.swift

@@ -119,6 +119,15 @@ public struct DeclSyntax: DeclSyntaxProtocol, SyntaxHashable {
     return Syntax(self).asProtocol(DeclSyntaxProtocol.self)!
   }
 
+  public static var childrenKeyPaths: [AnyKeyPath] {
+    fatalError("DeclSyntax is a base type and thus doesn't have statically known children")
+  }
+
+  public var childrenKeyPaths: [AnyKeyPath] {
+    return Syntax(self).childrenKeyPaths
+  }
+
+
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     return Syntax(self).childNameForDiagnostics(index)
   }
@@ -239,6 +248,15 @@ public struct ExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
     return Syntax(self).asProtocol(ExprSyntaxProtocol.self)!
   }
 
+  public static var childrenKeyPaths: [AnyKeyPath] {
+    fatalError("ExprSyntax is a base type and thus doesn't have statically known children")
+  }
+
+  public var childrenKeyPaths: [AnyKeyPath] {
+    return Syntax(self).childrenKeyPaths
+  }
+
+
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     return Syntax(self).childNameForDiagnostics(index)
   }
@@ -359,6 +377,15 @@ public struct StmtSyntax: StmtSyntaxProtocol, SyntaxHashable {
     return Syntax(self).asProtocol(StmtSyntaxProtocol.self)!
   }
 
+  public static var childrenKeyPaths: [AnyKeyPath] {
+    fatalError("StmtSyntax is a base type and thus doesn't have statically known children")
+  }
+
+  public var childrenKeyPaths: [AnyKeyPath] {
+    return Syntax(self).childrenKeyPaths
+  }
+
+
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     return Syntax(self).childNameForDiagnostics(index)
   }
@@ -479,6 +506,15 @@ public struct TypeSyntax: TypeSyntaxProtocol, SyntaxHashable {
     return Syntax(self).asProtocol(TypeSyntaxProtocol.self)!
   }
 
+  public static var childrenKeyPaths: [AnyKeyPath] {
+    fatalError("TypeSyntax is a base type and thus doesn't have statically known children")
+  }
+
+  public var childrenKeyPaths: [AnyKeyPath] {
+    return Syntax(self).childrenKeyPaths
+  }
+
+
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     return Syntax(self).childNameForDiagnostics(index)
   }
@@ -599,6 +635,15 @@ public struct PatternSyntax: PatternSyntaxProtocol, SyntaxHashable {
     return Syntax(self).asProtocol(PatternSyntaxProtocol.self)!
   }
 
+  public static var childrenKeyPaths: [AnyKeyPath] {
+    fatalError("PatternSyntax is a base type and thus doesn't have statically known children")
+  }
+
+  public var childrenKeyPaths: [AnyKeyPath] {
+    return Syntax(self).childrenKeyPaths
+  }
+
+
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     return Syntax(self).childNameForDiagnostics(index)
   }

Sources/SwiftSyntax/gyb_generated/SyntaxCollections.swift

@@ -17,6 +17,10 @@ public protocol SyntaxCollection: SyntaxProtocol, Sequence {
   var count: Int { get }
 }
 
+public extension SyntaxCollection {
+  static var childrenKeyPaths: [AnyKeyPath] { [] }
+}
+
 
 /// `CodeBlockItemListSyntax` represents a collection of one or more
 /// `CodeBlockItemSyntax` nodes. CodeBlockItemListSyntax behaves