Make underlying data structures of SyntaxData.Info classes insted of structs

This will allow us to add more data to `SyntaxData.Info.Root` without increasing the size of `SyntaxData`. It shouldn’t have a big performance impact at the moment since `Root.arena` is never accessed and only exists to keep `arena` a live.

x

Author: ahoppen

Sources/SwiftSyntax/Syntax.swift

@@ -23,21 +23,58 @@ public struct Syntax: SyntaxProtocol, SyntaxHashable {
   final class Info: @unchecked Sendable {
     // For root node.
     struct Root: Sendable {
-      private var arena: RetainedSyntaxArena
+      private let arena: RetainedSyntaxArena
 
       init(arena: RetainedSyntaxArena) {
         self.arena = arena
       }
     }
 
+    /// Class that owns a `Root`, is responsible for keeping it alive and also offers an unsafe pointer way to
+    /// access it.
+    ///
+    /// This way, the root node of a tree can own the root info and all other nodes in the tree can have an unsafe
+    /// pointer reference to the root info, which doesn't involve ref counting.
+    final class RefCountedRoot: Sendable {
+      /// `nonisolated(unsafe)` if fine because there are only two ways this gets accessed:
+      ///  - `pointer`: Here we reference `value` via inout to get a pointer to `Root` but the pointer is not mutable
+      ///    so no mutation happens here
+      #if swift(>=6)
+      private nonisolated(unsafe) var value: Root
+      #else
+      private var value: Root
+      #endif
+
+      fileprivate init(_ value: Root) {
+        self.value = value
+      }
+
+      fileprivate var pointer: UnsafePointer<Root> {
+        return withUnsafePointer(to: &value) { $0 }
+      }
+    }
+
     // For non-root nodes.
     struct NonRoot: Sendable {
       var parent: Syntax
       var absoluteInfo: AbsoluteSyntaxInfo
+      // `nonisolated(unsafe)` is fine because `Root` is owned by `RefCountedRoot` and `RefCountedRoot` guarantees that
+      // `Root` is not changing after the tree has been created.
+      #if swift(>=6)
+      nonisolated(unsafe) var rootInfo: UnsafePointer<Root>
+      #else
+      var rootInfo: UnsafePointer<Root>
+      #endif
+
+      init(parent: Syntax, absoluteInfo: AbsoluteSyntaxInfo, rootInfo: UnsafePointer<Root>) {
+        self.parent = parent
+        self.absoluteInfo = absoluteInfo
+        self.rootInfo = rootInfo
+      }
     }
 
     enum InfoImpl: Sendable {
-      case root(Root)
+      case root(RefCountedRoot)
       case nonRoot(NonRoot)
     }
 
@@ -67,9 +104,9 @@ public struct Syntax: SyntaxProtocol, SyntaxHashable {
   var info: Info!
   let raw: RawSyntax
 
-  private var rootInfo: Info.Root {
+  var rootInfo: UnsafePointer<Info.Root> {
     switch info.info! {
-    case .root(let info): return info
+    case .root(let info): return info.pointer
     case .nonRoot(let info): return info.parent.rootInfo
     }
   }
@@ -135,7 +172,7 @@ public struct Syntax: SyntaxProtocol, SyntaxHashable {
   }
 
   init(_ raw: RawSyntax, parent: Syntax, absoluteInfo: AbsoluteSyntaxInfo) {
-    self.init(raw, info: Info(.nonRoot(.init(parent: parent, absoluteInfo: absoluteInfo))))
+    self.init(raw, info: Info(.nonRoot(.init(parent: parent, absoluteInfo: absoluteInfo, rootInfo: parent.rootInfo))))
   }
 
   /// Creates a `Syntax` with the provided raw syntax and parent.
@@ -155,12 +192,15 @@ public struct Syntax: SyntaxProtocol, SyntaxHashable {
   ///     has a chance to retain it.
   static func forRoot(_ raw: RawSyntax, rawNodeArena: RetainedSyntaxArena) -> Syntax {
     precondition(rawNodeArena == raw.arenaReference)
-    return Syntax(raw, info: Info(.root(.init(arena: rawNodeArena))))
+    return Syntax(raw, info: Info(.root(Syntax.Info.RefCountedRoot(Syntax.Info.Root(arena: rawNodeArena)))))
   }
 
   static func forRoot(_ raw: RawSyntax, rawNodeArena: SyntaxArena) -> Syntax {
     precondition(rawNodeArena == raw.arenaReference)
-    return Syntax(raw, info: Info(.root(.init(arena: RetainedSyntaxArena(rawNodeArena)))))
+    return Syntax(
+      raw,
+      info: Info(.root(Syntax.Info.RefCountedRoot(Syntax.Info.Root(arena: RetainedSyntaxArena(rawNodeArena)))))
+    )
   }
 
   /// Returns the child data at the provided index in this data's layout.

Sources/SwiftSyntax/SyntaxNodeFactory.swift

@@ -65,7 +65,7 @@ struct SyntaxNodeFactory {
   @inline(__always)
   func create(parent: Syntax, raw: RawSyntax, absoluteInfo: AbsoluteSyntaxInfo) -> Syntax {
     if let info = syntaxInfoRepo.pop() {
-      info.info = .nonRoot(.init(parent: parent, absoluteInfo: absoluteInfo))
+      info.info = .nonRoot(.init(parent: parent, absoluteInfo: absoluteInfo, rootInfo: parent.rootInfo))
       return Syntax(raw, info: info)
     } else {
       return Syntax(raw, parent: parent, absoluteInfo: absoluteInfo)

Tests/SwiftSyntaxTest/MemoryLayoutTest.swift

@@ -35,7 +35,7 @@ final class MemoryLayoutTest: XCTestCase {
       "Syntax": .init(size: 16, stride: 16, alignment: 8),
       "Syntax.Info": .init(size: 8, stride: 8, alignment: 8),
       "Syntax.Info.Root": .init(size: 8, stride: 8, alignment: 8),
-      "Syntax.Info.NonRoot": .init(size: 36, stride: 40, alignment: 8),
+      "Syntax.Info.NonRoot": .init(size: 48, stride: 48, alignment: 8),
     ]
 
     let values = SyntaxMemoryLayout.values