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.

Author: ahoppen

Sources/SwiftSyntax/SyntaxData.swift

@@ -182,34 +182,57 @@ struct AbsoluteRawSyntax {
   }
 }
 
+class Wrapper<T> {
+  var value: T
+
+  init(_ value: T) {
+    self.value = value
+  }
+
+  var pointer: UnsafeMutablePointer<T> {
+    return withUnsafeMutablePointer(to: &value) { $0 }
+  }
+}
+
 /// SyntaxData is the underlying storage for each Syntax node.
 ///
 /// SyntaxData is an implementation detail, and should not be exposed to clients
 /// of SwiftSyntax.
 struct SyntaxData {
   fileprivate enum Info {
-    case root(Root)
+    case root(Wrapper<Root>)
     indirect case nonRoot(NonRoot)
 
     // For root node.
     struct Root {
       var arena: SyntaxArena
+
+      init(arena: SyntaxArena) {
+        self.arena = arena
+      }
     }
 
     // For non-root nodes.
     struct NonRoot {
       var parent: SyntaxData
       var absoluteInfo: AbsoluteSyntaxInfo
+      var rootInfo: UnsafeMutablePointer<Root>
+
+      init(parent: SyntaxData, absoluteInfo: AbsoluteSyntaxInfo, rootInfo: UnsafeMutablePointer<Root>) {
+        self.parent = parent
+        self.absoluteInfo = absoluteInfo
+        self.rootInfo = rootInfo
+      }
     }
   }
 
   private let info: Info
   let raw: RawSyntax
 
-  private var rootInfo: Info.Root {
+  private var rootInfo: UnsafeMutablePointer<Info.Root> {
     switch info {
-    case .root(let info): return info
-    case .nonRoot(let info): return info.parent.rootInfo
+    case .root(let info): return info.pointer
+    case .nonRoot(let info): return info.rootInfo
     }
   }
 
@@ -274,7 +297,7 @@ struct SyntaxData {
   }
 
   init(_ raw: RawSyntax, parent: SyntaxData, absoluteInfo: AbsoluteSyntaxInfo) {
-    self.init(raw, info: .nonRoot(.init(parent: parent, absoluteInfo: absoluteInfo)))
+    self.init(raw, info: .nonRoot(.init(parent: parent, absoluteInfo: absoluteInfo, rootInfo: parent.rootInfo)))
   }
 
   /// Creates a `SyntaxData` with the provided raw syntax and parent.
@@ -294,7 +317,7 @@ struct SyntaxData {
   ///     has a chance to retain it.
   static func forRoot(_ raw: RawSyntax, rawNodeArena: SyntaxArena) -> SyntaxData {
     precondition(rawNodeArena === raw.arena)
-    return SyntaxData(raw, info: .root(.init(arena: rawNodeArena)))
+    return SyntaxData(raw, info: .root(Wrapper(Info.Root(arena: rawNodeArena))))
   }
 
   /// Returns the child data at the provided index in this data's layout.