Revert "Use RawSyntax address as the 'rootId' of SyntaxIdentifier"

Package.swift

@@ -68,7 +68,7 @@ let package = Package(
     ),
     .target(
       name: "SwiftSyntax",
-      dependencies: [],
+      dependencies: ["_CSwiftSyntax"],
       exclude: [
         "CMakeLists.txt",
         "Misc.swift.gyb",
@@ -101,7 +101,7 @@ let package = Package(
     ),
     .target(
       name: "SwiftSyntaxParser",
-      dependencies: ["SwiftSyntax", "_CSwiftSyntax"],
+      dependencies: ["SwiftSyntax"],
       exclude: [
         "NodeDeclarationHash.swift.gyb",
         "Serialization.swift.gyb",

Sources/SwiftSyntax/AtomicCounter.swift

@@ -0,0 +1,21 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2022 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+@_implementationOnly import _CSwiftSyntax
+
+/// Provides API to get an atomically increasing counter value.
+struct AtomicCounter {
+  /// Get an atomically increasing counter value.
+  static func next() -> UInt64 {
+    return cswiftsyntax_get_unique_counter()
+  }
+}

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: UInt) {
+  init(index: SyntaxChildrenIndexData, rootId: UInt32) {
     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: UInt
+  private let rootId: UInt32
   /// 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 func forRoot(_ raw: RawSyntax) -> AbsoluteSyntaxInfo {
-    return .init(position: .forRoot, nodeId: .forRoot(raw))
+  static var forRoot: AbsoluteSyntaxInfo {
+    return .init(position: .forRoot, nodeId: .newRoot())
   }
 }
 
@@ -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: UInt
+  let rootId: UInt32
   /// 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 forRoot(_ raw: RawSyntax) -> SyntaxIdentifier {
-    return .init(rootId: UInt(bitPattern: raw.pointer),
+  static func newRoot() -> SyntaxIdentifier {
+    return .init(rootId: UInt32(truncatingIfNeeded: AtomicCounter.next()),
                  indexInTree: .zero)
   }
 }
@@ -168,14 +168,14 @@ struct AbsoluteRawSyntax {
     return nil
   }
 
-  func replacingSelf(_ newRaw: RawSyntax, newRootId: UInt) -> AbsoluteRawSyntax {
+  func replacingSelf(_ newRaw: RawSyntax, newRootId: UInt32) -> 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(raw))
+    return .init(raw: raw, info: .forRoot)
   }
 }
 

Sources/_CSwiftSyntax/include/atomic-counter.h

@@ -0,0 +1,3 @@
+#include <stdint.h>
+
+uint64_t cswiftsyntax_get_unique_counter(void);

Sources/_CSwiftSyntax/src/atomic-counter.c

@@ -0,0 +1,6 @@
+#include "atomic-counter.h"
+
+uint64_t cswiftsyntax_get_unique_counter(void) {
+  static _Atomic uint64_t counter = 0;
+  return ++counter;
+}

utils/group.json

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