Eliminate SyntaxArena.default

SyntaxArena.default was a global arena which just leaked.
Eliminate it, and make all Syntax factory/modifier API receive an
optioal SyntaxArena parameter. If the parameter is omitted, use a new
arena.

rdar://101894396

Author: rintaro

Sources/SwiftSyntax/Raw/RawSyntax.swift

@@ -219,7 +219,7 @@ extension RawSyntax {
   /// If the syntax tree did not contain a token and thus no trivia could be attached to it, `nil` is returned.
   /// - Parameters:
   ///   - leadingTrivia: The trivia to attach.
-  func withLeadingTrivia(_ leadingTrivia: Trivia) -> RawSyntax? {
+  func withLeadingTrivia(_ leadingTrivia: Trivia, arena: SyntaxArena) -> RawSyntax? {
     switch view {
     case .token(let tokenView):
       return .makeMaterializedToken(
@@ -229,7 +229,7 @@ extension RawSyntax {
         arena: arena)
     case .layout(let layoutView):
       for (index, child) in layoutView.children.enumerated() {
-        if let replaced = child?.withLeadingTrivia(leadingTrivia) {
+        if let replaced = child?.withLeadingTrivia(leadingTrivia, arena: arena) {
           return layoutView.replacingChild(at: index, with: replaced, arena: arena)
         }
       }
@@ -241,7 +241,7 @@ extension RawSyntax {
   /// If the syntax tree did not contain a token and thus no trivia could be attached to it, `nil` is returned.
   /// - Parameters:
   ///   - trailingTrivia: The trivia to attach.
-  func withTrailingTrivia(_ trailingTrivia: Trivia) -> RawSyntax? {
+  func withTrailingTrivia(_ trailingTrivia: Trivia, arena: SyntaxArena) -> RawSyntax? {
     switch view {
     case .token(let tokenView):
       return .makeMaterializedToken(
@@ -251,7 +251,7 @@ extension RawSyntax {
         arena: arena)
     case .layout(let layoutView):
       for (index, child) in layoutView.children.enumerated().reversed() {
-        if let replaced = child?.withTrailingTrivia(trailingTrivia) {
+        if let replaced = child?.withTrailingTrivia(trailingTrivia, arena: arena) {
           return layoutView.replacingChild(at: index, with: replaced, arena: arena)
         }
       }

Sources/SwiftSyntax/Raw/RawSyntaxTokenView.swift

@@ -151,24 +151,24 @@ public struct RawSyntaxTokenView {
   /// Returns a `RawSyntax` node with the same source text but with the token
   /// kind changed to `newValue`.
   @_spi(RawSyntax)
-  public func withKind(_ newValue: TokenKind) -> RawSyntax {
+  public func withKind(_ newValue: TokenKind, arena: SyntaxArena) -> RawSyntax {
     switch raw.rawData.payload {
     case .parsedToken(_):
       // The wholeText can't be continuous anymore. Make a materialized token.
       return .makeMaterializedToken(
         kind: newValue,
         leadingTrivia: formLeadingTrivia(),
         trailingTrivia: formTrailingTrivia(),
-        arena: raw.arena)
+        arena: arena)
     case .materializedToken(var payload):
       let decomposed = newValue.decomposeToRaw()
       let rawKind = decomposed.rawKind
-      let text: SyntaxText = (decomposed.string.map({raw.arena.intern($0)}) ??
+      let text: SyntaxText = (decomposed.string.map({arena.intern($0)}) ??
                               decomposed.rawKind.defaultText ??
                               "")
       payload.tokenKind = rawKind
       payload.tokenText = text
-      return RawSyntax(arena: raw.arena, payload: .materializedToken(payload))
+      return RawSyntax(arena: arena, payload: .materializedToken(payload))
     default:
       preconditionFailure("'withTokenKind()' is called on non-token raw syntax")
     }

Sources/SwiftSyntax/Syntax.swift

@@ -481,14 +481,14 @@ public extension SyntaxProtocol {
 
   /// Returns a new syntax node with its leading trivia replaced
   /// by the provided trivia.
-  func withLeadingTrivia(_ leadingTrivia: Trivia) -> Self {
-    return Self(Syntax(data.withLeadingTrivia(leadingTrivia)))!
+  func withLeadingTrivia(_ leadingTrivia: Trivia, arena: SyntaxArena = SyntaxArena()) -> Self {
+    return Self(Syntax(data.withLeadingTrivia(leadingTrivia, arena: arena)))!
   }
 
   /// Returns a new syntax node with its trailing trivia replaced
   /// by the provided trivia.
-  func withTrailingTrivia(_ trailingTrivia: Trivia) -> Self {
-    return Self(Syntax(data.withTrailingTrivia(trailingTrivia)))!
+  func withTrailingTrivia(_ trailingTrivia: Trivia, arena: SyntaxArena = SyntaxArena()) -> Self {
+    return Self(Syntax(data.withTrailingTrivia(trailingTrivia, arena: arena)))!
   }
 
   /// Returns a new syntax node with its leading trivia removed.

Sources/SwiftSyntax/SyntaxArena.swift

@@ -250,12 +250,6 @@ struct SyntaxArenaRef: Equatable {
   }
 }
 
-extension SyntaxArena {
-  // FIXME: This is only for migration. All clients should move to "arena" model.
-  //@available(*, deprecated, message: ".default SyntaxArena is subject to remove soon")
-  public static let `default` = SyntaxArena()
-}
-
 private func _defaultParseTriviaFunction(_ source: SyntaxText, _ position: TriviaPosition) -> [RawTriviaPiece] {
   preconditionFailure("Trivia parsing not supported")
 }

Sources/SwiftSyntax/SyntaxCollections.swift.gyb

@@ -117,9 +117,16 @@ public struct ${node.name}: SyntaxCollection, SyntaxHashable {
     self._syntaxNode = Syntax(data)
   }
 
-  public init(_ children: [Element]) {
+  public init(_ children: [Element]) { self.init(children, arena: SyntaxArena()) }
+
+% # NOTE: Don't make 'arena' defaulted because:
+% # * Some clients use 'XXXListSyntax.init' as a '([Element]) -> XXXListSyntax'
+% #   function
+% # * SyntaxBuilder has e.g. 'init(_: [ExprSyntaxProtocol])' method that makes
+% #   'XXXListSyntax([ExprSyntax(node)!])' ambiguous
+  public init(_ children: [Element], arena: SyntaxArena) {
     let raw = RawSyntax.makeLayout(kind: SyntaxKind.${node.swift_syntax_kind},
-      from: children.map { $0.raw }, arena: .default)
+      from: children.map { $0.raw }, arena: arena)
     let data = SyntaxData.forRoot(raw)
     self.init(data)
   }
@@ -134,9 +141,10 @@ public struct ${node.name}: SyntaxCollection, SyntaxHashable {
   ///                     collection.
   /// - Returns: A new `${node.name}` with the new layout underlying it.
   internal func replacingLayout(
-    _ layout: [RawSyntax?]) -> ${node.name} {
-    let newRaw = layoutView.replacingLayout(with: layout, arena: .default)
-    let newData = data.replacingSelf(newRaw)
+    _ layout: [RawSyntax?],
+    arena: SyntaxArena) -> ${node.name} {
+    let newRaw = layoutView.replacingLayout(with: layout, arena: arena)
+    let newData = data.replacingSelf(newRaw, arena: arena)
     return ${node.name}(newData)
   }
 
@@ -145,10 +153,10 @@ public struct ${node.name}: SyntaxCollection, SyntaxHashable {
   ///
   /// - Parameter syntax: The element to append.
   /// - Returns: A new `${node.name}` with that element appended to the end.
-  public func appending(_ syntax: Element) -> ${node.name} {
+  public func appending(_ syntax: Element, arena: SyntaxArena = SyntaxArena()) -> ${node.name} {
     var newLayout = layoutView.formLayoutArray()
     newLayout.append(syntax.raw)
-    return replacingLayout(newLayout)
+    return replacingLayout(newLayout, arena: arena)
   }
 
   /// Creates a new `${node.name}` by prepending the provided syntax element
@@ -157,8 +165,8 @@ public struct ${node.name}: SyntaxCollection, SyntaxHashable {
   /// - Parameter syntax: The element to prepend.
   /// - Returns: A new `${node.name}` with that element prepended to the
   ///            beginning.
-  public func prepending(_ syntax: Element) -> ${node.name} {
-    return inserting(syntax, at: 0)
+  public func prepending(_ syntax: Element, arena: SyntaxArena = SyntaxArena()) -> ${node.name} {
+    return inserting(syntax, at: 0, arena: arena)
   }
 
   /// Creates a new `${node.name}` by inserting the provided syntax element
@@ -169,13 +177,13 @@ public struct ${node.name}: SyntaxCollection, SyntaxHashable {
   ///   - index: The index at which to insert the element in the collection.
   ///
   /// - Returns: A new `${node.name}` with that element appended to the end.
-  public func inserting(_ syntax: Element, at index: Int) -> ${node.name} {
+  public func inserting(_ syntax: Element, at index: Int, arena: SyntaxArena = SyntaxArena()) -> ${node.name} {
     var newLayout = layoutView.formLayoutArray()
     /// Make sure the index is a valid insertion index (0 to 1 past the end)
     precondition((newLayout.startIndex...newLayout.endIndex).contains(index),
                  "inserting node at invalid index \(index)")
     newLayout.insert(syntax.raw, at: index)
-    return replacingLayout(newLayout)
+    return replacingLayout(newLayout, arena: arena)
   }
 
   /// Creates a new `${node.name}` by replacing the syntax element
@@ -186,13 +194,13 @@ public struct ${node.name}: SyntaxCollection, SyntaxHashable {
   ///   - syntax: The element to replace with.
   ///
   /// - Returns: A new `${node.name}` with the new element at the provided index.
-  public func replacing(childAt index: Int, with syntax: Element) -> ${node.name} {
+  public func replacing(childAt index: Int, with syntax: Element, arena: SyntaxArena = SyntaxArena()) -> ${node.name} {
     var newLayout = layoutView.formLayoutArray()
     /// Make sure the index is a valid index for replacing
     precondition((newLayout.startIndex..<newLayout.endIndex).contains(index),
                  "replacing node at invalid index \(index)")
     newLayout[index] = syntax.raw
-    return replacingLayout(newLayout)
+    return replacingLayout(newLayout, arena: arena)
   }
 
   /// Creates a new `${node.name}` by removing the syntax element at the
@@ -201,55 +209,55 @@ public struct ${node.name}: SyntaxCollection, SyntaxHashable {
   /// - Parameter index: The index of the element to remove from the collection.
   /// - Returns: A new `${node.name}` with the element at the provided index
   ///            removed.
-  public func removing(childAt index: Int) -> ${node.name} {
+  public func removing(childAt index: Int, arena: SyntaxArena = SyntaxArena()) -> ${node.name} {
     var newLayout = layoutView.formLayoutArray()
     newLayout.remove(at: index)
-    return replacingLayout(newLayout)
+    return replacingLayout(newLayout, arena: arena)
   }
 
   /// Creates a new `${node.name}` by removing the first element.
   ///
   /// - Returns: A new `${node.name}` with the first element removed.
-  public func removingFirst() -> ${node.name} {
+  public func removingFirst(arena: SyntaxArena = SyntaxArena()) -> ${node.name} {
     var newLayout = layoutView.formLayoutArray()
     newLayout.removeFirst()
-    return replacingLayout(newLayout)
+    return replacingLayout(newLayout, arena: arena)
   }
 
   /// Creates a new `${node.name}` by removing the last element.
   ///
   /// - Returns: A new `${node.name}` with the last element removed.
-  public func removingLast() -> ${node.name} {
+  public func removingLast(arena: SyntaxArena = SyntaxArena()) -> ${node.name} {
     var newLayout = layoutView.formLayoutArray()
     newLayout.removeLast()
-    return replacingLayout(newLayout)
+    return replacingLayout(newLayout, arena: arena)
   }
 
   /// Returns a new `${node.name}` with its leading trivia replaced
   /// by the provided trivia.
-  public func withLeadingTrivia(_ leadingTrivia: Trivia) -> ${node.name} {
-    return ${node.name}(data.withLeadingTrivia(leadingTrivia))
+  public func withLeadingTrivia(_ leadingTrivia: Trivia, arena: SyntaxArena = SyntaxArena()) -> ${node.name} {
+    return ${node.name}(data.withLeadingTrivia(leadingTrivia, arena: arena))
   }
 
   /// Returns a new `${node.name}` with its trailing trivia replaced
   /// by the provided trivia.
-  public func withTrailingTrivia(_ trailingTrivia: Trivia) -> ${node.name} {
-    return ${node.name}(data.withTrailingTrivia(trailingTrivia))
+  public func withTrailingTrivia(_ trailingTrivia: Trivia, arena: SyntaxArena = SyntaxArena()) -> ${node.name} {
+    return ${node.name}(data.withTrailingTrivia(trailingTrivia, arena: arena))
   }
 
   /// Returns a new `${node.name}` with its leading trivia removed.
-  public func withoutLeadingTrivia() -> ${node.name} {
-    return withLeadingTrivia([])
+  public func withoutLeadingTrivia(arena: SyntaxArena = SyntaxArena()) -> ${node.name} {
+    return withLeadingTrivia([], arena: arena)
   }
 
   /// Returns a new `${node.name}` with its trailing trivia removed.
-  public func withoutTrailingTrivia() -> ${node.name} {
-    return withTrailingTrivia([])
+  public func withoutTrailingTrivia(arena: SyntaxArena = SyntaxArena()) -> ${node.name} {
+    return withTrailingTrivia([], arena: arena)
   }
 
   /// Returns a new `${node.name}` with all trivia removed.
-  public func withoutTrivia() -> ${node.name} {
-    return withoutLeadingTrivia().withoutTrailingTrivia()
+  public func withoutTrivia(arena: SyntaxArena = SyntaxArena()) -> ${node.name} {
+    return withoutLeadingTrivia(arena: arena).withoutTrailingTrivia(arena: arena)
   }
 
   /// The leading trivia (spaces, newlines, etc.) associated with this `${node.name}`.

Sources/SwiftSyntax/SyntaxData.swift

@@ -325,12 +325,11 @@ struct SyntaxData {
   /// - parameter newRaw: The new RawSyntax that will back the new `Data`
   /// - returns: A tuple of both the new root node and the new data with the raw
   ///            layout replaced.
-  func replacingSelf(
-    _ newRaw: RawSyntax) -> SyntaxData {
+  func replacingSelf(_ newRaw: RawSyntax, arena: SyntaxArena) -> SyntaxData {
     // If we have a parent already, then ask our current parent to copy itself
     // recursively up to the root.
     if let parent = parent {
-      let parentData = parent.replacingChild(newRaw, at: indexInParent)
+      let parentData = parent.replacingChild(newRaw, at: indexInParent, arena: arena)
       let newParent = Syntax(parentData)
       return SyntaxData(absoluteRaw.replacingSelf(newRaw, newRootId: parentData.nodeId.rootId), parent: newParent)
     } else {
@@ -349,22 +348,22 @@ struct SyntaxData {
   /// - Returns: The new root node created by this operation, and the new child
   ///            syntax data.
   /// - SeeAlso: replacingSelf(_:)
-  func replacingChild(_ child: RawSyntax?, at index: Int) -> SyntaxData {
-    let newRaw = raw.layoutView!.replacingChild(at: index, with: child, arena: .default)
-    return replacingSelf(newRaw)
+  func replacingChild(_ child: RawSyntax?, at index: Int, arena: SyntaxArena) -> SyntaxData {
+    let newRaw = raw.layoutView!.replacingChild(at: index, with: child, arena: arena)
+    return replacingSelf(newRaw, arena: arena)
   }
 
-  func withLeadingTrivia(_ leadingTrivia: Trivia) -> SyntaxData {
-    if let raw = raw.withLeadingTrivia(leadingTrivia) {
-      return replacingSelf(raw)
+  func withLeadingTrivia(_ leadingTrivia: Trivia, arena: SyntaxArena) -> SyntaxData {
+    if let raw = raw.withLeadingTrivia(leadingTrivia, arena: arena) {
+      return replacingSelf(raw, arena: arena)
     } else {
       return self
     }
   }
 
-  func withTrailingTrivia(_ trailingTrivia: Trivia) -> SyntaxData {
-    if let raw = raw.withTrailingTrivia(trailingTrivia) {
-      return replacingSelf(raw)
+  func withTrailingTrivia(_ trailingTrivia: Trivia, arena: SyntaxArena) -> SyntaxData {
+    if let raw = raw.withTrailingTrivia(trailingTrivia, arena: arena) {
+      return replacingSelf(raw, arena: arena)
     } else {
       return self
     }

Sources/SwiftSyntax/SyntaxFactory.swift.gyb

@@ -31,17 +31,19 @@ public enum SyntaxFactory {
   @available(*, deprecated, message: "Use initializer on TokenSyntax")
   public static func makeToken(_ kind: TokenKind, presence: SourcePresence,
                                leadingTrivia: Trivia = [],
-                               trailingTrivia: Trivia = []) -> TokenSyntax {
+                               trailingTrivia: Trivia = [],
+                               arena: SyntaxArena = SyntaxArena()) -> TokenSyntax {
     let raw = RawSyntax.makeMaterializedToken(kind: kind, leadingTrivia: leadingTrivia,
-      trailingTrivia: trailingTrivia, presence: presence, arena: .default)
+      trailingTrivia: trailingTrivia, presence: presence, arena: arena)
     let data = SyntaxData.forRoot(raw)
     return TokenSyntax(data)
   }
 
   @available(*, deprecated, message: "Use initializer on UnknownSyntax")
-  public static func makeUnknownSyntax(tokens: [TokenSyntax]) -> UnknownSyntax {
+  public static func makeUnknownSyntax(tokens: [TokenSyntax],
+                                       arena: SyntaxArena = SyntaxArena()) -> UnknownSyntax {
     let raw = RawSyntax.makeLayout(kind: .unknown,
-      from: tokens.map { $0.raw }, arena: .default)
+      from: tokens.map { $0.raw }, arena: arena)
     let data = SyntaxData.forRoot(raw)
     return UnknownSyntax(data)
   }
@@ -68,7 +70,7 @@ public enum SyntaxFactory {
 %     end
 %     child_params = ', '.join(child_params)
   @available(*, deprecated, message: "Use initializer on ${node.name}")
-  public static func make${node.syntax_kind}(${child_params}) -> ${node.name} {
+  public static func make${node.syntax_kind}(${child_params}, arena: SyntaxArena = SyntaxArena()) -> ${node.name} {
     let layout: [RawSyntax?] = [
 %     for child in node.children:
 %       if child.is_optional:
@@ -79,16 +81,17 @@ public enum SyntaxFactory {
 %     end
     ]
     let raw = RawSyntax.makeLayout(kind: SyntaxKind.${node.swift_syntax_kind},
-      from: layout, arena: .default)
+      from: layout, arena: arena)
     let data = SyntaxData.forRoot(raw)
     return ${node.name}(data)
   }
 %   elif node.is_syntax_collection():
   @available(*, deprecated, message: "Use initializer on ${node.name}")
   public static func make${node.syntax_kind}(
-    _ elements: [${node.collection_element_type}]) -> ${node.name} {
+    _ elements: [${node.collection_element_type}],
+    arena: SyntaxArena = SyntaxArena()) -> ${node.name} {
     let raw = RawSyntax.makeLayout(kind: SyntaxKind.${node.swift_syntax_kind},
-      from: elements.map { $0.raw }, arena: .default)
+      from: elements.map { $0.raw }, arena: arena)
     let data = SyntaxData.forRoot(raw)
     return ${node.name}(data)
   }
@@ -97,7 +100,7 @@ public enum SyntaxFactory {
 %   if not node.is_base():
 %   default_presence = 'missing' if node.is_missing() else 'present'
   @available(*, deprecated, message: "Use initializer on ${node.name}")
-  public static func makeBlank${node.syntax_kind}(presence: SourcePresence = .${default_presence}) -> ${node.name} {
+  public static func makeBlank${node.syntax_kind}(presence: SourcePresence = .${default_presence}, arena: SyntaxArena = SyntaxArena()) -> ${node.name} {
     let data = SyntaxData.forRoot(RawSyntax.makeLayout(kind: .${node.swift_syntax_kind},
       from: [
 %     for child in node.children:
@@ -107,7 +110,7 @@ public enum SyntaxFactory {
       ${make_missing_swift_child(child)},
 %       end
 %     end
-    ], arena: .default))
+    ], arena: arena))
     return ${node.name}(data)
   }
 %   end