Merge pull request swiftlang#662 from rintaro/nodeid-rawsyntaxaddr-simple

Reapply: Use RawSyntax address as the 'rootId' of SyntaxIdentifier

Author: rintaro

Diff for: 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?

Diff for: 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))
   }
 }
 
@@ -103,8 +103,13 @@ 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
+  /// Unique value for the root node.
+  ///
+  /// Multiple trees may have the same 'rootId' if their root RawSyntax is the
+  /// same instance. This guarantees that the trees with the same 'rootId' have
+  /// exact the same structure. But, two trees with exactly the same structure
+  /// might still have different 'rootId's.
+  let rootId: UInt
   /// Unique value for a node within its own tree.
   let indexInTree: SyntaxIndexInTree
 
@@ -123,8 +128,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 +173,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))
   }
 }