Remove indexInParent from SyntaxProtocol

Clients should never need to worry about a node’s index within the parent, especially because `indexInParent` will return the index while also including `nil` nodes and that’s a view of the tree you cannot get anywhere.

Author: ahoppen

CodeGeneration/Sources/SyntaxSupport/Classification.swift

@@ -28,16 +28,15 @@ public class SyntaxClassification {
 public class ChildClassification {
   public let parent: Node
   public let childIndex: Int
-  public let isToken: Bool
-  public let classification: SyntaxClassification?
-  public let force: Bool
+  public let child: Child
+  public var isToken: Bool { child.isToken }
+  public var classification: SyntaxClassification? { child.classification }
+  public var force: Bool { child.forceClassification }
 
   public init(node: Node, childIndex: Int, child: Child) {
     self.parent = node
     self.childIndex = childIndex
-    self.isToken = child.syntaxKind.hasSuffix("Token")
-    self.classification = child.classification
-    self.force = child.forceClassification
+    self.child = child
   }
 }
 

CodeGeneration/Sources/generate-swiftsyntax/templates/basicformat/BasicFormatFile.swift

@@ -62,7 +62,7 @@ let basicFormatFile = SourceFileSyntax(leadingTrivia: copyrightHeader) {
     DeclSyntax(
       """
       open override func visitPre(_ node: Syntax) {
-        if let keyPath = getKeyPath(node), shouldIndent(keyPath) {
+        if let keyPath = node.keyPathInParent, shouldIndent(keyPath) {
           indentationLevel += 1
         }
         if let parent = node.parent, childrenSeparatedByNewline(parent) {
@@ -74,7 +74,7 @@ let basicFormatFile = SourceFileSyntax(leadingTrivia: copyrightHeader) {
     DeclSyntax(
       """
       open override func visitPost(_ node: Syntax) {
-        if let keyPath = getKeyPath(node), shouldIndent(keyPath) {
+        if let keyPath = node.keyPathInParent, shouldIndent(keyPath) {
           indentationLevel -= 1
         }
       }
@@ -92,7 +92,7 @@ let basicFormatFile = SourceFileSyntax(leadingTrivia: copyrightHeader) {
         if requiresTrailingSpace(node) && trailingTrivia.isEmpty {
           trailingTrivia += .space
         }
-        if let keyPath = getKeyPath(Syntax(node)), requiresLeadingNewline(keyPath), !(leadingTrivia.first?.isNewline ?? false), !shouldOmitNewline(node) {
+        if let keyPath = node.keyPathInParent, requiresLeadingNewline(keyPath), !(leadingTrivia.first?.isNewline ?? false), !shouldOmitNewline(node) {
           leadingTrivia = .newline + leadingTrivia
         }
         var isOnNewline: Bool = (lastRewrittenToken?.trailingTrivia.pieces.last?.isNewline == true)
@@ -206,7 +206,7 @@ let basicFormatFile = SourceFileSyntax(leadingTrivia: copyrightHeader) {
     try FunctionDeclSyntax("open func requiresLeadingSpace(_ token: TokenSyntax) -> Bool") {
       StmtSyntax(
         """
-        if let keyPath = getKeyPath(token), let requiresLeadingSpace = requiresLeadingSpace(keyPath) {
+        if let keyPath = token.keyPathInParent, let requiresLeadingSpace = requiresLeadingSpace(keyPath) {
           return requiresLeadingSpace
         }
         """
@@ -268,7 +268,7 @@ let basicFormatFile = SourceFileSyntax(leadingTrivia: copyrightHeader) {
     try FunctionDeclSyntax("open func requiresTrailingSpace(_ token: TokenSyntax) -> Bool") {
       StmtSyntax(
         """
-        if let keyPath = getKeyPath(token), let requiresTrailingSpace = requiresTrailingSpace(keyPath) {
+        if let keyPath = token.keyPathInParent, let requiresTrailingSpace = requiresTrailingSpace(keyPath) {
           return requiresTrailingSpace
         }
         """
@@ -311,19 +311,5 @@ let basicFormatFile = SourceFileSyntax(leadingTrivia: copyrightHeader) {
         }
       }
     }
-
-    DeclSyntax(
-      """
-      private func getKeyPath<T: SyntaxProtocol>(_ node: T) -> AnyKeyPath? {
-        guard let parent = node.parent else {
-          return nil
-        }
-        guard case .layout(let childrenKeyPaths) = parent.kind.syntaxNodeType.structure else {
-          return nil
-        }
-        return childrenKeyPaths[node.indexInParent]
-      }
-      """
-    )
   }
 }

CodeGeneration/Sources/generate-swiftsyntax/templates/ideutils/SyntaxClassificationFile.swift

@@ -53,35 +53,17 @@ let syntaxClassificationFile = SourceFileSyntax(leadingTrivia: copyrightHeader)
       ///   - childKind: The node syntax kind.
       /// - Returns: A pair of classification and whether it is "forced", or nil if
       ///   no classification is attached.
-      internal static func classify(
-          parentKind: SyntaxKind, indexInParent: Int, childKind: SyntaxKind
-        ) -> (SyntaxClassification, Bool)?
+      internal static func classify(_ keyPath: AnyKeyPath) -> (SyntaxClassification, Bool)?
       """
     ) {
-      try IfExprSyntax(
-        """
-        // Separate checks for token nodes (most common checks) versus checks for layout nodes.
-        if childKind == .token
-        """
-      ) {
-        try SwitchExprSyntax("switch (parentKind, indexInParent)") {
-          for childClassification in node_child_classifications where childClassification.isToken {
-            SwitchCaseSyntax("case (.\(raw: childClassification.parent.swiftSyntaxKind), \(raw: childClassification.childIndex)):") {
-              StmtSyntax("return (.\(raw: childClassification.classification!.swiftName), \(raw: childClassification.force))")
-            }
+      try SwitchExprSyntax("switch keyPath") {
+        for childClassification in node_child_classifications {
+          SwitchCaseSyntax("case \\\(raw: childClassification.parent.type.syntaxBaseName).\(raw: childClassification.child.swiftName):") {
+            StmtSyntax("return (.\(raw: childClassification.classification!.swiftName), \(raw: childClassification.force))")
           }
-
-          SwitchCaseSyntax("default: return nil")
         }
-      } else: {
-        try SwitchExprSyntax("switch (parentKind, indexInParent)") {
-          for childClassification in node_child_classifications where !childClassification.isToken {
-            SwitchCaseSyntax("case (.\(raw: childClassification.parent.swiftSyntaxKind), \(raw: childClassification.childIndex)):") {
-              StmtSyntax("return (.\(raw: childClassification.classification!.swiftName), \(raw: childClassification.force))")
-            }
-          }
-
-          SwitchCaseSyntax("default: return nil")
+        SwitchCaseSyntax("default:") {
+          StmtSyntax("return nil")
         }
       }
     }

CodeGeneration/Sources/generate-swiftsyntax/templates/swiftparserdiagnostics/ChildNameForDiagnosticsFile.swift

@@ -40,25 +40,11 @@ let childNameForDiagnosticFile = SourceFileSyntax(leadingTrivia: copyrightHeader
     }
   }
 
-  DeclSyntax(
-    """
-    private func getKeyPath<T: SyntaxProtocol>(_ node: T) -> AnyKeyPath? {
-      guard let parent = node.parent else {
-        return nil
-      }
-      guard case .layout(let childrenKeyPaths) = parent.kind.syntaxNodeType.structure else {
-        return nil
-      }
-      return childrenKeyPaths[node.indexInParent]
-    }
-    """
-  )
-
   DeclSyntax(
     """
     extension SyntaxProtocol {
       var childNameInParent: String? {
-        guard let keyPath = getKeyPath(self) else {
+        guard let keyPath = self.keyPathInParent else {
           return nil
         }
         return childNameForDiagnostics(keyPath)

Sources/IDEUtils/SyntaxClassifier.swift

@@ -17,12 +17,8 @@ fileprivate extension SyntaxProtocol {
     var contextualClassif: (SyntaxClassification, Bool)? = nil
     var curData = Syntax(self)
     repeat {
-      guard let parent = curData.parent else { break }
-      contextualClassif = SyntaxClassification.classify(
-        parentKind: parent.raw.kind,
-        indexInParent: curData.indexInParent,
-        childKind: raw.kind
-      )
+      guard let parent = curData.parent, let keyPath = curData.keyPathInParent else { break }
+      contextualClassif = SyntaxClassification.classify(keyPath)
       curData = parent
     } while contextualClassif == nil
     return contextualClassif
@@ -35,7 +31,7 @@ extension TokenSyntax {
     let contextualClassification = self.contextualClassification
     let relativeOffset = leadingTriviaLength.utf8Length
     let absoluteOffset = position.utf8Offset + relativeOffset
-    return TokenKindAndText(kind: rawTokenKind, text: tokenView.rawText).classify(
+    return TokenKindAndText(kind: tokenView.rawKind, text: tokenView.rawText).classify(
       offset: absoluteOffset,
       contextualClassification: contextualClassification
     )
@@ -200,16 +196,17 @@ private struct ClassificationVisitor {
 
     for case (let index, let child?) in children.enumerated() {
 
-      let classficiation = SyntaxClassification.classify(
-        parentKind: descriptor.node.kind,
-        indexInParent: index,
-        childKind: child.kind
-      )
+      let classification: (SyntaxClassification, Bool)?
+      if case .layout(let layout) = descriptor.node.kind.syntaxNodeType.structure {
+        classification = SyntaxClassification.classify(layout[index])
+      } else {
+        classification = nil
+      }
       let result = visit(
         .init(
           node: child,
           byteOffset: byteOffset,
-          contextualClassification: classficiation ?? descriptor.contextualClassification
+          contextualClassification: classification ?? descriptor.contextualClassification
         )
       )
       if result == .break {

Sources/IDEUtils/generated/SyntaxClassification.swift

@@ -65,52 +65,42 @@ extension SyntaxClassification {
   ///   - childKind: The node syntax kind.
   /// - Returns: A pair of classification and whether it is "forced", or nil if
   ///   no classification is attached.
-  internal static func classify(
-    parentKind: SyntaxKind, indexInParent: Int, childKind: SyntaxKind
-  ) -> (SyntaxClassification, Bool)? {
-    // Separate checks for token nodes (most common checks) versus checks for layout nodes.
-    if childKind == .token {
-      switch (parentKind, indexInParent) {
-      case (.availabilityVersionRestriction, 1):
-        return (.keyword, false)
-      case (.declModifier, 1):
-        return (.attribute, false)
-      case (.expressionSegment, 5):
-        return (.stringInterpolationAnchor, true)
-      case (.expressionSegment, 9):
-        return (.stringInterpolationAnchor, true)
-      case (.forInStmt, 5):
-        return (.keyword, false)
-      case (.ifConfigClause, 1):
-        return (.buildConfigId, false)
-      case (.ifConfigDecl, 3):
-        return (.buildConfigId, false)
-      case (.memberTypeIdentifier, 5):
-        return (.typeIdentifier, false)
-      case (.operatorDecl, 7):
-        return (.operatorIdentifier, false)
-      case (.precedenceGroupAssociativity, 1):
-        return (.keyword, false)
-      case (.precedenceGroupRelation, 1):
-        return (.keyword, false)
-      case (.simpleTypeIdentifier, 1):
-        return (.typeIdentifier, false)
-      default: 
-        return nil
-      }
-    }else {
-      switch (parentKind, indexInParent) {
-      case (.attribute, 3):
-        return (.attribute, false)
-      case (.availabilityVersionRestrictionListEntry, 1):
-        return (.keyword, false)
-      case (.ifConfigClause, 3):
-        return (.buildConfigId, false)
-      case (.operatorDecl, 3):
-        return (.attribute, false)
-      default: 
-        return nil
-      }
+  internal static func classify(_ keyPath: AnyKeyPath) -> (SyntaxClassification, Bool)? {
+    switch keyPath {
+    case \AttributeSyntax.attributeName:
+      return (.attribute, false)
+    case \AvailabilityVersionRestrictionListEntrySyntax.availabilityVersionRestriction:
+      return (.keyword, false)
+    case \AvailabilityVersionRestrictionSyntax.platform:
+      return (.keyword, false)
+    case \DeclModifierSyntax.name:
+      return (.attribute, false)
+    case \ExpressionSegmentSyntax.leftParen:
+      return (.stringInterpolationAnchor, true)
+    case \ExpressionSegmentSyntax.rightParen:
+      return (.stringInterpolationAnchor, true)
+    case \ForInStmtSyntax.awaitKeyword:
+      return (.keyword, false)
+    case \IfConfigClauseSyntax.poundKeyword:
+      return (.buildConfigId, false)
+    case \IfConfigClauseSyntax.condition:
+      return (.buildConfigId, false)
+    case \IfConfigDeclSyntax.poundEndif:
+      return (.buildConfigId, false)
+    case \MemberTypeIdentifierSyntax.name:
+      return (.typeIdentifier, false)
+    case \OperatorDeclSyntax.modifiers:
+      return (.attribute, false)
+    case \OperatorDeclSyntax.identifier:
+      return (.operatorIdentifier, false)
+    case \PrecedenceGroupAssociativitySyntax.associativityKeyword:
+      return (.keyword, false)
+    case \PrecedenceGroupRelationSyntax.higherThanOrLowerThan:
+      return (.keyword, false)
+    case \SimpleTypeIdentifierSyntax.name:
+      return (.typeIdentifier, false)
+    default:
+      return nil
     }
   }
 }

Sources/SwiftBasicFormat/generated/BasicFormat.swift

@@ -30,7 +30,7 @@ open class BasicFormat: SyntaxRewriter {
   private var putNextTokenOnNewLine: Bool = false
 
   open override func visitPre(_ node: Syntax) {
-    if let keyPath = getKeyPath(node), shouldIndent(keyPath) {
+    if let keyPath = node.keyPathInParent, shouldIndent(keyPath) {
       indentationLevel += 1
     }
     if let parent = node.parent, childrenSeparatedByNewline(parent) {
@@ -39,7 +39,7 @@ open class BasicFormat: SyntaxRewriter {
   }
 
   open override func visitPost(_ node: Syntax) {
-    if let keyPath = getKeyPath(node), shouldIndent(keyPath) {
+    if let keyPath = node.keyPathInParent, shouldIndent(keyPath) {
       indentationLevel -= 1
     }
   }
@@ -53,7 +53,7 @@ open class BasicFormat: SyntaxRewriter {
     if requiresTrailingSpace(node) && trailingTrivia.isEmpty {
       trailingTrivia += .space
     }
-    if let keyPath = getKeyPath(Syntax(node)), requiresLeadingNewline(keyPath), !(leadingTrivia.first?.isNewline ?? false), !shouldOmitNewline(node) {
+    if let keyPath = node.keyPathInParent, requiresLeadingNewline(keyPath), !(leadingTrivia.first?.isNewline ?? false), !shouldOmitNewline(node) {
       leadingTrivia = .newline + leadingTrivia
     }
     var isOnNewline: Bool = (lastRewrittenToken?.trailingTrivia.pieces.last?.isNewline == true)
@@ -176,7 +176,7 @@ open class BasicFormat: SyntaxRewriter {
   }
 
   open func requiresLeadingSpace(_ token: TokenSyntax) -> Bool {
-    if let keyPath = getKeyPath(token), let requiresLeadingSpace = requiresLeadingSpace(keyPath) {
+    if let keyPath = token.keyPathInParent, let requiresLeadingSpace = requiresLeadingSpace(keyPath) {
       return requiresLeadingSpace
     }
     switch (token.previousToken(viewMode: .sourceAccurate)?.tokenKind, token.tokenKind) {
@@ -231,7 +231,7 @@ open class BasicFormat: SyntaxRewriter {
   }
 
   open func requiresTrailingSpace(_ token: TokenSyntax) -> Bool {
-    if let keyPath = getKeyPath(token), let requiresTrailingSpace = requiresTrailingSpace(keyPath) {
+    if let keyPath = token.keyPathInParent, let requiresTrailingSpace = requiresTrailingSpace(keyPath) {
       return requiresTrailingSpace
     }
     switch (token.tokenKind, token.nextToken(viewMode: .sourceAccurate)?.tokenKind) {
@@ -363,14 +363,4 @@ open class BasicFormat: SyntaxRewriter {
       return false
     }
   }
-  
-  private func getKeyPath<T: SyntaxProtocol>(_ node: T) -> AnyKeyPath? {
-    guard let parent = node.parent else {
-      return nil
-    }
-    guard case .layout(let childrenKeyPaths) = parent.kind.syntaxNodeType.structure else {
-      return nil
-    }
-    return childrenKeyPaths[node.indexInParent]
-  }
 }

Sources/SwiftParserDiagnostics/generated/ChildNameForDiagnostics.swift

@@ -367,19 +367,9 @@ private func childNameForDiagnostics(_ keyPath: AnyKeyPath) -> String? {
   }
 }
 
-private func getKeyPath<T: SyntaxProtocol>(_ node: T) -> AnyKeyPath? {
-  guard let parent = node.parent else {
-    return nil
-  }
-  guard case .layout(let childrenKeyPaths) = parent.kind.syntaxNodeType.structure else {
-    return nil
-  }
-  return childrenKeyPaths[node.indexInParent]
-}
-
 extension SyntaxProtocol {
   var childNameInParent: String? {
-    guard let keyPath = getKeyPath(self) else {
+    guard let keyPath = self.keyPathInParent else {
       return nil
     }
     return childNameForDiagnostics(keyPath)