Performance improvements for SyntaxRewriter

Improve the performance of SyntaxRewriter by avoiding unnecessary
casts, reusing the SyntaxBox and eliminating .enumerated()

Author: ahoppen

Sources/SwiftSyntax/SyntaxData.swift

@@ -162,7 +162,7 @@ struct AbsoluteRawSyntax {
 
 /// Indirect wrapper for a `Syntax` node to avoid cyclic inclusion of the 
 /// `Syntax` struct in `SyntaxData`
-fileprivate class SyntaxBox: CustomStringConvertible, 
+class SyntaxBox: CustomStringConvertible, 
     CustomDebugStringConvertible, TextOutputStreamable {
   let value: Syntax
 
@@ -173,18 +173,18 @@ fileprivate class SyntaxBox: CustomStringConvertible,
   // SyntaxBox should be transparent in all descriptions
 
   /// A source-accurate description of this node.
-  public var description: String {
+  var description: String {
     return value.description
   }
 
   /// Returns a description used by dump.
-  public var debugDescription: String {
+  var debugDescription: String {
     return value.debugDescription
   }
 
   /// Prints the raw value of this node to the provided stream.
   /// - Parameter stream: The stream to which to print the raw tree.
-  public func write<Target>(to target: inout Target)
+  func write<Target>(to target: inout Target)
     where Target: TextOutputStream {
     return value.write(to: &target)
   }
@@ -236,6 +236,16 @@ struct SyntaxData {
     self.parentBox = parent.map(SyntaxBox.init)
   }
 
+  /// Creates a `SyntaxData` with the provided raw syntax and parent.
+  /// - Parameters:
+  ///   - absoluteRaw: The underlying `AbsoluteRawSyntax` of this node.
+  ///   - parentBox: The boxed parent of this node, or `nil` if this node is the 
+  ///                root.
+  init(_ absoluteRaw: AbsoluteRawSyntax, parentBox: SyntaxBox?) {
+    self.absoluteRaw = absoluteRaw
+    self.parentBox = parentBox
+  }
+
   /// Creates a `SyntaxData` for a root raw node.
   static func forRoot(_ raw: RawSyntax) -> SyntaxData {
     return SyntaxData(.forRoot(raw), parent: nil)

Sources/SwiftSyntax/SyntaxRewriter.swift.gyb

@@ -85,15 +85,17 @@ open class SyntaxRewriter {
   private func visitImpl${node.name}(_ data: SyntaxData) -> Syntax {
 %   if node.is_base():
       let node = Unknown${node.name}(data)
-      visitPre(Syntax(node))
-      defer { visitPost(Syntax(node)) }
-      if let newNode = visitAny(Syntax(node)) { return newNode }
+      // Accessing _syntaxNode directly is faster than calling Syntax(node)
+      visitPre(node._syntaxNode)
+      defer { visitPost(node._syntaxNode) }
+      if let newNode = visitAny(node._syntaxNode) { return newNode }
       return Syntax(visit(node))
 %   else:
       let node = ${node.name}(data)
-      visitPre(Syntax(node))
-      defer { visitPost(Syntax(node)) }
-      if let newNode = visitAny(Syntax(node)) { return newNode }
+      // Accessing _syntaxNode directly is faster than calling Syntax(node)
+      visitPre(node._syntaxNode)
+      defer { visitPost(node._syntaxNode) }
+      if let newNode = visitAny(node._syntaxNode) { return newNode }
 %     if node.base_type == 'Syntax':
       return visit(node)
 %     else:
@@ -108,15 +110,17 @@ open class SyntaxRewriter {
     switch data.raw.kind {
     case .token:
       let node = TokenSyntax(data)
-      visitPre(Syntax(node))
-      defer { visitPost(Syntax(node)) }
-      if let newNode = visitAny(Syntax(node)) { return newNode }
+      // Accessing _syntaxNode directly is faster than calling Syntax(node)
+      visitPre(node._syntaxNode)
+      defer { visitPost(node._syntaxNode) }
+      if let newNode = visitAny(node._syntaxNode) { return newNode }
       return visit(node)
     case .unknown:
       let node = UnknownSyntax(data)
-      visitPre(Syntax(node))
-      defer { visitPost(Syntax(node)) }
-      if let newNode = visitAny(Syntax(node)) { return newNode }
+      // Accessing _syntaxNode directly is faster than calling Syntax(node)
+      visitPre(node._syntaxNode)
+      defer { visitPost(node._syntaxNode) }
+      if let newNode = visitAny(node._syntaxNode) { return newNode }
       return visit(node)
     // The implementation of every generated case goes into its own function. This
     // circumvents an issue where the compiler allocates stack space for every
@@ -142,7 +146,13 @@ open class SyntaxRewriter {
     // nodes are being collected.
     var newLayout: ContiguousArray<RawSyntax?>?
 
-    for (i, (raw, info)) in RawSyntaxChildren(Syntax(node)).enumerated() {
+    let syntaxNode = node._syntaxNode
+    let parentBox = SyntaxBox(syntaxNode)
+
+    // Incrementing i manually is faster than using .enumerated()
+    var childIndex = 0
+    for (raw, info) in RawSyntaxChildren(Syntax(node)) {
+      defer { childIndex += 1 }
       guard let child = raw else {
         // Node does not exist. If we are collecting rewritten nodes, we need to 
         // collect this one as well, otherwise we can ignore it.
@@ -154,7 +164,7 @@ open class SyntaxRewriter {
 
       // Build the Syntax node to rewrite
       let absoluteRaw = AbsoluteRawSyntax(raw: child, info: info)
-      let data = SyntaxData(absoluteRaw, parent: Syntax(node))
+      let data = SyntaxData(absoluteRaw, parentBox: parentBox)
 
       let rewritten = visit(data)
       if rewritten.data.nodeId != info.nodeId {
@@ -168,7 +178,7 @@ open class SyntaxRewriter {
           // reserves enough capacity for the entire layout.
           newLayout = ContiguousArray<RawSyntax?>()
           newLayout!.reserveCapacity(node.raw.numberOfChildren)
-          for j in 0..<i {
+          for j in 0..<childIndex {
             newLayout!.append(node.raw.child(at: j))
           }
         }