Use RawSyntax address as the 'rootId' of SyntaxIdentifier

We don't need to guarantee the uniqueness throughout the process
lifetime. but only need to guarantee the uniqueness while the object is
alive.

This removes  `_CSwiftSyntax` dependency  from `SwiftSyntax` module.

Author: rintaro

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/AtomicCounter.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/SyntaxChildren.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/SwiftSyntax/SyntaxData.swift

@@ -0,0 +1 @@
+

Sources/_CSwiftSyntax/include/atomic-counter.h

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