Only store indexInTree in SyntaxChildrenIndex

Author: ahoppen

Sources/SwiftSyntax/SyntaxChildren.swift

@@ -13,26 +13,24 @@
 public struct SyntaxChildrenIndex: Comparable {
   fileprivate let offset: UInt32
   fileprivate let indexInParent: UInt32
-  // TODO: We can retrieve the rootId from the collection's node and could just
-  // store indexInTree instead of the entire identifier
-  fileprivate let identifier: SyntaxIdentifier
+  fileprivate let indexInTree: SyntaxIndexInTree
 
   public static func <(lhs: SyntaxChildrenIndex, rhs: SyntaxChildrenIndex)
       -> Bool {
     return lhs.indexInParent < rhs.indexInParent
   }
 
   fileprivate init(offset: UInt32, indexInParent: UInt32,
-                   identifier: SyntaxIdentifier) {
+                   indexInTree: SyntaxIndexInTree) {
     self.offset = offset
     self.indexInParent = indexInParent
-    self.identifier = identifier
+    self.indexInTree = indexInTree
   }
 
   init(_ absoluteSyntaxInfo: AbsoluteSyntaxInfo) {
     self.offset = absoluteSyntaxInfo.offset
     self.indexInParent = absoluteSyntaxInfo.indexInParent
-    self.identifier = absoluteSyntaxInfo.nodeId
+    self.indexInTree = absoluteSyntaxInfo.nodeId.indexInTree
   }
 }
 
@@ -44,6 +42,7 @@ struct RawSyntaxChildren: BidirectionalCollection {
 
   /// The node whose children shall be accessed
   private let parent: RawSyntax
+  private let rootId: UInt32
 
   let startIndex: SyntaxChildrenIndex
   let endIndex: SyntaxChildrenIndex
@@ -53,28 +52,31 @@ struct RawSyntaxChildren: BidirectionalCollection {
     let nodeLength = UInt32(node?.totalLength.utf8Length ?? 0)
     return SyntaxChildrenIndex(offset: index.offset + nodeLength,
              indexInParent: index.indexInParent + 1,
-             identifier: index.identifier.advancedBySibling(node))
+             indexInTree: index.indexInTree.advancedBySibling(node))
   }
 
   func index(before index: SyntaxChildrenIndex) -> SyntaxChildrenIndex {
     let previousNode = parent.child(at: Int(index.indexInParent - 1))
     let previousNodeLength = UInt32(previousNode?.totalLength.utf8Length ?? 0)
     return SyntaxChildrenIndex(offset: index.offset - previousNodeLength,
              indexInParent: index.indexInParent - 1,
-             identifier: index.identifier.reversedBySibling(previousNode))
+             indexInTree: index.indexInTree.reversedBySibling(previousNode))
   }
 
   subscript(index: SyntaxChildrenIndex)
       -> (node: RawSyntax?, info: AbsoluteSyntaxInfo) {
     let child = parent.child(at: Int(index.indexInParent))
     let position = AbsoluteSyntaxPosition(offset: index.offset,
                                           indexInParent: index.indexInParent)
-    let info = AbsoluteSyntaxInfo(position: position, nodeId: index.identifier)
+    let identifier = SyntaxIdentifier(rootId: rootId,
+                                      indexInTree: index.indexInTree)
+    let info = AbsoluteSyntaxInfo(position: position, nodeId: identifier)
     return (child, info)
   }
 
   init(_ parent: AbsoluteRawSyntax) {
     self.parent = parent.raw
+    self.rootId = parent.info.nodeId.rootId
 
     let startPosition = parent.info.advancedToFirstChild()
     self.startIndex = SyntaxChildrenIndex(startPosition)

Sources/SwiftSyntax/SyntaxData.swift

@@ -81,35 +81,66 @@ struct AbsoluteSyntaxInfo {
   }
 }
 
+/// Represents a unique value for a node within its own tree.
+struct SyntaxIndexInTree: Hashable {
+  let indexInTree: UInt32
+
+  static var zero: SyntaxIndexInTree = SyntaxIndexInTree(indexInTree: 0)
+
+  func advancedBySibling(_ raw: RawSyntax?) -> SyntaxIndexInTree {
+    let newIndexInTree = self.indexInTree + UInt32(truncatingIfNeeded: raw?.totalNodes ?? 0)
+    return .init(indexInTree: newIndexInTree)
+  }
+
+  func reversedBySibling(_ raw: RawSyntax?) -> SyntaxIndexInTree {
+    let newIndexInTree = self.indexInTree - UInt32(truncatingIfNeeded: raw?.totalNodes ?? 0)
+    return .init(indexInTree: newIndexInTree)
+  }
+
+  func advancedToFirstChild() -> SyntaxIndexInTree {
+    let newIndexInTree = self.indexInTree + 1
+    return .init(indexInTree: newIndexInTree)
+  }
+
+  func advancedToEndOfChildren(_ raw: RawSyntax) -> SyntaxIndexInTree {
+    let newIndexInTree = self.indexInTree + UInt32(truncatingIfNeeded: raw.totalNodes)
+    return .init(indexInTree: newIndexInTree)
+  }
+
+  private init(indexInTree: UInt32) {
+    self.indexInTree = indexInTree
+  }
+}
+
 /// Provides a stable and unique identity for `Syntax` nodes.
 public struct SyntaxIdentifier: Hashable {
   /// Unique value for each root node created.
   let rootId: UInt32
   /// Unique value for a node within its own tree.
-  let indexInTree: UInt32
+  let indexInTree: SyntaxIndexInTree
 
   func advancedBySibling(_ raw: RawSyntax?) -> SyntaxIdentifier {
-    let newIndexInTree = self.indexInTree + UInt32(truncatingIfNeeded: raw?.totalNodes ?? 0)
+    let newIndexInTree = indexInTree.advancedBySibling(raw)
     return .init(rootId: self.rootId, indexInTree: newIndexInTree)
   }
 
   func reversedBySibling(_ raw: RawSyntax?) -> SyntaxIdentifier {
-    let newIndexInTree = self.indexInTree - UInt32(truncatingIfNeeded: raw?.totalNodes ?? 0)
+    let newIndexInTree = self.indexInTree.reversedBySibling(raw)
     return .init(rootId: self.rootId, indexInTree: newIndexInTree)
   }
 
   func advancedToFirstChild() -> SyntaxIdentifier {
-    let newIndexInTree = self.indexInTree + 1
+    let newIndexInTree = self.indexInTree.advancedToFirstChild()
     return .init(rootId: self.rootId, indexInTree: newIndexInTree)
   }
 
   func advancedToEndOfChildren(_ raw: RawSyntax) -> SyntaxIdentifier {
-    let newIndexInTree = self.indexInTree + UInt32(truncatingIfNeeded: raw.totalNodes)
+    let newIndexInTree = self.indexInTree.advancedToEndOfChildren(raw)
     return .init(rootId: self.rootId, indexInTree: newIndexInTree)
   }
 
   static func newRoot() -> SyntaxIdentifier {
-    return .init(rootId: UInt32(truncatingIfNeeded: AtomicCounter.next()), indexInTree: 0)
+    return .init(rootId: UInt32(truncatingIfNeeded: AtomicCounter.next()), indexInTree: .zero)
   }
 }