Use RawSyntax address as the 'rootId' of SyntaxIdentifier

Package.swift

@@ -64,7 +64,7 @@ let package = Package(
     ),
     .target(
       name: "SwiftSyntax",
-      dependencies: ["_CSwiftSyntax"],
+      dependencies: [],
       exclude: [
         "Misc.swift.gyb",
         "Raw/RawSyntaxNodes.swift.gyb",
@@ -96,7 +96,7 @@ let package = Package(
     ),
     .target(
       name: "SwiftSyntaxParser",
-      dependencies: ["SwiftSyntax"],
+      dependencies: ["SwiftSyntax", "_CSwiftSyntax"],
       exclude: [
         "NodeDeclarationHash.swift.gyb",
         "Serialization.swift.gyb",

Sources/SwiftSyntax/SyntaxChildren.swift

@@ -91,7 +91,7 @@ public struct SyntaxChildrenIndex: Comparable, ExpressibleByNilLiteral {
 
 fileprivate extension AbsoluteSyntaxInfo {
   /// Construct `AbsoluteSyntaxInfo` from the given index data and a `rootId`.
-  init(index: SyntaxChildrenIndexData, rootId: UInt32) {
+  init(index: SyntaxChildrenIndexData, rootId: UInt) {
     let position = AbsoluteSyntaxPosition(offset: index.offset,
                                           indexInParent: index.indexInParent)
     let identifier = SyntaxIdentifier(rootId: rootId,
@@ -137,7 +137,7 @@ struct RawSyntaxChildren: BidirectionalCollection {
   }
 
   /// The rootId of the tree the child nodes belong to
-  private let rootId: UInt32
+  private let rootId: UInt
   /// The number of childer in `parent`. Cached to avoid reaching into `parent` for every index
   /// advancement
   // FIXME: Do we need this cached?

Sources/SwiftSyntax/SyntaxData.swift

@@ -64,8 +64,8 @@ struct AbsoluteSyntaxInfo {
     return .init(position: newPosition, nodeId: newNodeId)
   }
 
-  static var forRoot: AbsoluteSyntaxInfo {
-    return .init(position: .forRoot, nodeId: .newRoot())
+  static func forRoot(_ raw: RawSyntax) -> AbsoluteSyntaxInfo {
+    return .init(position: .forRoot, nodeId: .forRoot(raw))
   }
 }
 
@@ -104,7 +104,7 @@ struct SyntaxIndexInTree: Hashable {
 /// Provides a stable and unique identity for `Syntax` nodes.
 public struct SyntaxIdentifier: Hashable {
   /// Unique value for each root node created.
-  let rootId: UInt32
+  let rootId: UInt
   /// Unique value for a node within its own tree.
   let indexInTree: SyntaxIndexInTree
 
@@ -123,8 +123,8 @@ public struct SyntaxIdentifier: Hashable {
     return .init(rootId: self.rootId, indexInTree: newIndexInTree)
   }
 
-  static func newRoot() -> SyntaxIdentifier {
-    return .init(rootId: UInt32(truncatingIfNeeded: AtomicCounter.next()),
+  static func forRoot(_ raw: RawSyntax) -> SyntaxIdentifier {
+    return .init(rootId: UInt(bitPattern: raw.pointer),
                  indexInTree: .zero)
   }
 }
@@ -168,14 +168,14 @@ struct AbsoluteRawSyntax {
     return nil
   }
 
-  func replacingSelf(_ newRaw: RawSyntax, newRootId: UInt32) -> AbsoluteRawSyntax {
+  func replacingSelf(_ newRaw: RawSyntax, newRootId: UInt) -> AbsoluteRawSyntax {
     let nodeId = SyntaxIdentifier(rootId: newRootId, indexInTree: info.nodeId.indexInTree)
     let newInfo = AbsoluteSyntaxInfo(position: info.position, nodeId: nodeId)
     return .init(raw: newRaw, info: newInfo)
   }
 
   static func forRoot(_ raw: RawSyntax) -> AbsoluteRawSyntax {
-    return .init(raw: raw, info: .forRoot)
+    return .init(raw: raw, info: .forRoot(raw))
   }
 }
 

Sources/_CSwiftSyntax/src/dummy.c

@@ -0,0 +1 @@
+

utils/group.json

@@ -53,7 +53,6 @@
   ],
   "Internal": [
     "SyntaxArena.swift",
-    "AtomicCounter.swift",
     "SyntaxVerifier.swift",
     "BumpPtrAllocator.swift",
   ]