[NFC] Rename 'arena:' argument labels

Author: rintaro

CodeGeneration/Sources/generate-swift-syntax/templates/swiftsyntax/SyntaxNodesFile.swift

@@ -163,7 +163,7 @@ func syntaxNode(nodesStartingWith: [Character]) -> SourceFileSyntax {
             AccessorDeclSyntax(
               """
               set(value) {
-                self = Syntax(self).replacingChild(at: \(raw: index), with: Syntax(value), arena: RawSyntaxArena()).cast(\(node.kind.syntaxType).self)
+                self = Syntax(self).replacingChild(at: \(raw: index), with: Syntax(value), rawAllocationArena: RawSyntaxArena()).cast(\(node.kind.syntaxType).self)
               }
               """
             )
@@ -200,7 +200,7 @@ func syntaxNode(nodesStartingWith: [Character]) -> SourceFileSyntax {
                                                     from: [element.raw], arena: arena)
                 }
                 return Syntax(self)
-                  .replacingChild(at: \(raw: index), with: collection, rawNodeArena: arena, allocationArena: arena)
+                  .replacingChild(at: \(raw: index), with: collection, rawNodeArena: arena, rawAllocationArena: arena)
                   .cast(\(node.kind.syntaxType).self)
               }
               """

CodeGeneration/Sources/generate-swift-syntax/templates/swiftsyntax/SyntaxRewriterFile.swift

@@ -33,30 +33,30 @@ let syntaxRewriterFile = SourceFileSyntax(leadingTrivia: copyrightHeader) {
     DeclSyntax("public let viewMode: SyntaxTreeViewMode")
     DeclSyntax(
       """
-      /// The arena in which the parents of rewritten nodes should be allocated.
+      /// The raw arena in which the parents of rewritten nodes should be allocated.
       /// 
       /// The `SyntaxRewriter` subclass is responsible for generating the rewritten nodes. To incorporate them into the
       /// tree, all of the rewritten node's parents also need to be re-created. This is the arena in which those 
-      /// intermediate nodes should be allocated.
-      private let arena: RawSyntaxArena?
+      /// intermediate raw nodes should be allocated.
+      private let rawArena: RawSyntaxArena?
       """
     )
 
     DeclSyntax(
       """
       public init(viewMode: SyntaxTreeViewMode = .sourceAccurate) {
         self.viewMode = viewMode
-        self.arena = nil
+        self.rawArena = nil
       }
       """
     )
 
     DeclSyntax(
       """
       @_spi(RawSyntax)
-      public init(viewMode: SyntaxTreeViewMode = .sourceAccurate, arena: RawSyntaxArena? = nil) {
+      public init(viewMode: SyntaxTreeViewMode = .sourceAccurate, rawAllocationArena: RawSyntaxArena? = nil) {
         self.viewMode = viewMode
-        self.arena = arena
+        self.rawArena = rawAllocationArena
       }
       """
     )
@@ -71,7 +71,7 @@ let syntaxRewriterFile = SourceFileSyntax(leadingTrivia: copyrightHeader) {
         }
 
         return withExtendedLifetime(rewritten) {
-          return Syntax(node).replacingSelf(rewritten.raw, rawNodeArena: rewritten.raw.arenaReference.retained, allocationArena: RawSyntaxArena())
+          return Syntax(node).replacingSelf(rewritten.raw, rawNodeArena: rewritten.raw.arenaReference.retained, rawAllocationArena: RawSyntaxArena())
         }
       }
       """
@@ -347,13 +347,13 @@ let syntaxRewriterFile = SourceFileSyntax(leadingTrivia: copyrightHeader) {
         if newLayout.baseAddress != nil {
           // A child node was rewritten. Build the updated node.
 
-          let arena = self.arena ?? RawSyntaxArena()
-          let newRaw = node.raw.layoutView!.replacingLayout(with: newLayout, arena: arena)
+          let rawArena = self.rawArena ?? RawSyntaxArena()
+          let newRaw = node.raw.layoutView!.replacingLayout(with: newLayout, arena: rawArena)
           newLayout.deinitialize()
           newLayout.deallocate()
           // 'withExtendedLifetime' to keep 'RawSyntaxArena's of them alive until here.
           return withExtendedLifetime(rewrittens) {
-            Syntax(raw: newRaw, rawNodeArena: arena)
+            Syntax(raw: newRaw, rawNodeArena: rawArena)
           }
         } else {
           // No child node was rewritten. So no need to change this node as well.

Sources/SwiftParser/Parser.swift

@@ -831,7 +831,7 @@ extension Parser {
 
   /// Creates a replicate of `syntax` with all tokens marked as missing.
   func withAllTokensMarkedMissing<T: RawSyntaxNodeProtocol>(syntax: T) -> T {
-    let tokenMissingMaker = TokenMissingMaker(arena: self.arena)
+    let tokenMissingMaker = TokenMissingMaker(rawAllocationArena: self.arena)
     let allMissing = tokenMissingMaker.rewrite(
       Syntax(raw: RawSyntax(syntax), rawNodeArena: self.arena)
     ).raw

Sources/SwiftSyntax/Syntax.swift

@@ -144,10 +144,14 @@ public struct Syntax: SyntaxProtocol, SyntaxHashable {
   /// - Parameters:
   ///   - newRaw: The node that should replace `self`
   ///   - rawNodeArena: The arena in which `newRaw` resides
-  ///   - allocationArena: The arena in which  new nodes should be allocated
+  ///   - rawAllocationArena: The arena in which  new nodes should be allocated
   /// - Returns: A syntax tree with all parents where this node has been
   ///            replaced by `newRaw`
-  func replacingSelf(_ newRaw: RawSyntax, rawNodeArena: RetainedRawSyntaxArena, allocationArena: RawSyntaxArena) -> Syntax {
+  func replacingSelf(
+    _ newRaw: RawSyntax,
+    rawNodeArena: RetainedRawSyntaxArena,
+    rawAllocationArena: RawSyntaxArena
+  ) -> Syntax {
     precondition(newRaw.arenaReference == rawNodeArena)
     // If we have a parent already, then ask our current parent to copy itself
     // recursively up to the root.
@@ -156,7 +160,7 @@ public struct Syntax: SyntaxProtocol, SyntaxHashable {
         at: layoutIndexInParent,
         with: newRaw,
         rawNodeArena: rawNodeArena,
-        allocationArena: allocationArena
+        rawAllocationArena: rawAllocationArena
       )
       return newParent.child(at: layoutIndexInParent)!
     } else {
@@ -172,75 +176,91 @@ public struct Syntax: SyntaxProtocol, SyntaxHashable {
   ///   - index: The index pointing to where in the raw layout to place this
   ///            child.
   ///   - newChild: The raw syntax for the new child to replace.
-  ///   - newChildArena: The arena in which `newChild` resides.
-  ///   - arena: The arena in which the new node will be allocated.
+  ///   - rawNodeArena: The arena in which `newChild` resides.
+  ///   - rawAllocationArena: The arena in which the new node will be allocated.
   /// - Returns: The new root node created by this operation, and the new child
   ///            syntax data.
   /// - SeeAlso: replacingSelf(_:)
   func replacingChild(
     at index: Int,
     with newChild: RawSyntax?,
     rawNodeArena: RetainedRawSyntaxArena?,
-    allocationArena: RawSyntaxArena
+    rawAllocationArena: RawSyntaxArena
   ) -> Syntax {
     precondition(newChild == nil || (rawNodeArena != nil && newChild!.arenaReference == rawNodeArena!))
     // After newRaw has been allocated in `allocationArena`, `rawNodeArena` will
     // be a child arena of `allocationArena` and thus, `allocationArena` will
     // keep `newChild` alive.
     let newRaw = withExtendedLifetime(rawNodeArena) {
-      raw.layoutView!.replacingChild(at: index, with: newChild, arena: allocationArena)
+      raw.layoutView!.replacingChild(at: index, with: newChild, arena: rawAllocationArena)
     }
-    return replacingSelf(newRaw, rawNodeArena: RetainedRawSyntaxArena(allocationArena), allocationArena: allocationArena)
+    return replacingSelf(
+      newRaw,
+      rawNodeArena: RetainedRawSyntaxArena(rawAllocationArena),
+      rawAllocationArena: rawAllocationArena
+    )
   }
 
-  /// Same as `replacingChild(at:with:rawNodeArena:allocationArena:)` but takes a `__RawSyntaxArena` instead of a `RetainedRawSyntaxArena`.
+  /// Same as `replacingChild(at:with:rawNodeArena:rawAllocationArena:)` but takes a `__RawSyntaxArena` instead of a `RetainedRawSyntaxArena`.
   func replacingChild(
     at index: Int,
     with newChild: RawSyntax?,
     rawNodeArena: RawSyntaxArena?,
-    allocationArena: RawSyntaxArena
+    rawAllocationArena: RawSyntaxArena
   ) -> Syntax {
     return self.replacingChild(
       at: index,
       with: newChild,
       rawNodeArena: rawNodeArena.map(RetainedRawSyntaxArena.init),
-      allocationArena: allocationArena
+      rawAllocationArena: rawAllocationArena
     )
   }
 
-  /// Identical to `replacingChild(at: Int, with: RawSyntax?, arena: RawSyntaxArena)`
+  /// Identical to `replacingChild(at: Int, with: RawSyntax?, rawAllocationArena: RawSyntaxArena)`
   /// that ensures that the arena of`newChild` doesn’t get de-allocated before
   /// `newChild` has been addded to the result.
-  func replacingChild(at index: Int, with newChild: Syntax?, arena: RawSyntaxArena) -> Syntax {
+  func replacingChild(at index: Int, with newChild: Syntax?, rawAllocationArena: RawSyntaxArena) -> Syntax {
     return withExtendedLifetime(newChild) {
       return replacingChild(
         at: index,
         with: newChild?.raw,
         rawNodeArena: newChild?.raw.arenaReference.retained,
-        allocationArena: arena
+        rawAllocationArena: rawAllocationArena
       )
     }
   }
 
-  func withLeadingTrivia(_ leadingTrivia: Trivia, arena: RawSyntaxArena) -> Syntax {
-    if let raw = raw.withLeadingTrivia(leadingTrivia, arena: arena) {
-      return replacingSelf(raw, rawNodeArena: RetainedRawSyntaxArena(arena), allocationArena: arena)
+  func withLeadingTrivia(_ leadingTrivia: Trivia, rawAllocationArena: RawSyntaxArena) -> Syntax {
+    if let raw = raw.withLeadingTrivia(leadingTrivia, arena: rawAllocationArena) {
+      return replacingSelf(
+        raw,
+        rawNodeArena: RetainedRawSyntaxArena(rawAllocationArena),
+        rawAllocationArena: rawAllocationArena
+      )
     } else {
       return self
     }
   }
 
-  func withTrailingTrivia(_ trailingTrivia: Trivia, arena: RawSyntaxArena) -> Syntax {
-    if let raw = raw.withTrailingTrivia(trailingTrivia, arena: arena) {
-      return replacingSelf(raw, rawNodeArena: RetainedRawSyntaxArena(arena), allocationArena: arena)
+  func withTrailingTrivia(_ trailingTrivia: Trivia, rawAllocationArena: RawSyntaxArena) -> Syntax {
+    if let raw = raw.withTrailingTrivia(trailingTrivia, arena: rawAllocationArena) {
+      return replacingSelf(
+        raw,
+        rawNodeArena: RetainedRawSyntaxArena(rawAllocationArena),
+        rawAllocationArena: rawAllocationArena
+      )
     } else {
       return self
     }
   }
 
-  func withPresence(_ presence: SourcePresence, arena: RawSyntaxArena) -> Syntax {
-    if let raw = raw.tokenView?.withPresence(presence, arena: arena) {
-      return replacingSelf(raw, rawNodeArena: RetainedRawSyntaxArena(arena), allocationArena: arena)
+  func withPresence(_ presence: SourcePresence, rawAllocationArena: RawSyntaxArena) -> Syntax {
+    if let raw = raw.tokenView?.withPresence(presence, arena: rawAllocationArena) {
+      return replacingSelf(
+        raw,
+        rawNodeArena: RetainedRawSyntaxArena(rawAllocationArena),
+        rawAllocationArena: rawAllocationArena
+      )
     } else {
       return self
     }

Sources/SwiftSyntax/SyntaxCollection.swift

@@ -71,7 +71,7 @@ extension SyntaxCollection {
     let arena = RawSyntaxArena()
     let newRaw = layoutView.replacingLayout(with: layout, arena: arena)
     return Syntax(self)
-      .replacingSelf(newRaw, rawNodeArena: RetainedRawSyntaxArena(arena), allocationArena: arena)
+      .replacingSelf(newRaw, rawNodeArena: RetainedRawSyntaxArena(arena), rawAllocationArena: arena)
       .cast(Self.self)
   }
 

Sources/SwiftSyntax/SyntaxProtocol.swift

@@ -484,7 +484,7 @@ extension SyntaxProtocol {
       return raw.formLeadingTrivia()
     }
     set {
-      self = Syntax(self).withLeadingTrivia(newValue, arena: RawSyntaxArena()).cast(Self.self)
+      self = Syntax(self).withLeadingTrivia(newValue, rawAllocationArena: RawSyntaxArena()).cast(Self.self)
     }
   }
 
@@ -503,7 +503,7 @@ extension SyntaxProtocol {
       return raw.formTrailingTrivia()
     }
     set {
-      self = Syntax(self).withTrailingTrivia(newValue, arena: RawSyntaxArena()).cast(Self.self)
+      self = Syntax(self).withTrailingTrivia(newValue, rawAllocationArena: RawSyntaxArena()).cast(Self.self)
     }
   }
 

Sources/SwiftSyntax/TokenSyntax.swift

@@ -71,7 +71,7 @@ public struct TokenSyntax: SyntaxProtocol, SyntaxHashable {
       return tokenView.presence
     }
     set {
-      self = Syntax(self).withPresence(newValue, arena: RawSyntaxArena()).cast(TokenSyntax.self)
+      self = Syntax(self).withPresence(newValue, rawAllocationArena: RawSyntaxArena()).cast(TokenSyntax.self)
     }
   }
 
@@ -91,7 +91,7 @@ public struct TokenSyntax: SyntaxProtocol, SyntaxHashable {
       return tokenView.formLeadingTrivia()
     }
     set {
-      self = Syntax(self).withLeadingTrivia(newValue, arena: RawSyntaxArena()).cast(TokenSyntax.self)
+      self = Syntax(self).withLeadingTrivia(newValue, rawAllocationArena: RawSyntaxArena()).cast(TokenSyntax.self)
     }
   }
 
@@ -101,7 +101,7 @@ public struct TokenSyntax: SyntaxProtocol, SyntaxHashable {
       return tokenView.formTrailingTrivia()
     }
     set {
-      self = Syntax(self).withTrailingTrivia(newValue, arena: RawSyntaxArena()).cast(TokenSyntax.self)
+      self = Syntax(self).withTrailingTrivia(newValue, rawAllocationArena: RawSyntaxArena()).cast(TokenSyntax.self)
     }
   }
 
@@ -117,7 +117,7 @@ public struct TokenSyntax: SyntaxProtocol, SyntaxHashable {
       let arena = RawSyntaxArena()
       let newRaw = tokenView.withKind(newValue, arena: arena)
       self = Syntax(self)
-        .replacingSelf(newRaw, rawNodeArena: RetainedRawSyntaxArena(arena), allocationArena: arena)
+        .replacingSelf(newRaw, rawNodeArena: RetainedRawSyntaxArena(arena), rawAllocationArena: arena)
         .cast(TokenSyntax.self)
     }
   }

Sources/SwiftSyntax/generated/SyntaxRewriter.swift

@@ -24,22 +24,22 @@
 open class SyntaxRewriter {
   public let viewMode: SyntaxTreeViewMode
 
-  /// The arena in which the parents of rewritten nodes should be allocated.
+  /// The raw arena in which the parents of rewritten nodes should be allocated.
   /// 
   /// The `SyntaxRewriter` subclass is responsible for generating the rewritten nodes. To incorporate them into the
   /// tree, all of the rewritten node's parents also need to be re-created. This is the arena in which those 
-  /// intermediate nodes should be allocated.
-  private let arena: RawSyntaxArena?
+  /// intermediate raw nodes should be allocated.
+  private let rawArena: RawSyntaxArena?
 
   public init(viewMode: SyntaxTreeViewMode = .sourceAccurate) {
     self.viewMode = viewMode
-    self.arena = nil
+    self.rawArena = nil
   }
 
   @_spi(RawSyntax)
-  public init(viewMode: SyntaxTreeViewMode = .sourceAccurate, arena: RawSyntaxArena? = nil) {
+  public init(viewMode: SyntaxTreeViewMode = .sourceAccurate, rawAllocationArena: RawSyntaxArena? = nil) {
     self.viewMode = viewMode
-    self.arena = arena
+    self.rawArena = rawAllocationArena
   }
 
   /// Rewrite `node`, keeping its parent unless `detach` is `true`.
@@ -50,7 +50,7 @@ open class SyntaxRewriter {
     }
 
     return withExtendedLifetime(rewritten) {
-      return Syntax(node).replacingSelf(rewritten.raw, rawNodeArena: rewritten.raw.arenaReference.retained, allocationArena: RawSyntaxArena())
+      return Syntax(node).replacingSelf(rewritten.raw, rawNodeArena: rewritten.raw.arenaReference.retained, rawAllocationArena: RawSyntaxArena())
     }
   }
 
@@ -4812,13 +4812,13 @@ open class SyntaxRewriter {
     if newLayout.baseAddress != nil {
       // A child node was rewritten. Build the updated node.
 
-      let arena = self.arena ?? RawSyntaxArena()
-      let newRaw = node.raw.layoutView!.replacingLayout(with: newLayout, arena: arena)
+      let rawArena = self.rawArena ?? RawSyntaxArena()
+      let newRaw = node.raw.layoutView!.replacingLayout(with: newLayout, arena: rawArena)
       newLayout.deinitialize()
       newLayout.deallocate()
       // 'withExtendedLifetime' to keep 'RawSyntaxArena's of them alive until here.
       return withExtendedLifetime(rewrittens) {
-        Syntax(raw: newRaw, rawNodeArena: arena)
+        Syntax(raw: newRaw, rawNodeArena: rawArena)
       }
     } else {
       // No child node was rewritten. So no need to change this node as well.