wip: fix review comments.

Author: nkcsgexi

Sources/SwiftSyntax/SyntaxRewriter.swift.gyb

@@ -140,24 +140,58 @@ open class SyntaxVisitor {
   }
 }
 
+
+class PendingSyntaxNode {
+  private let _parent: PendingSyntaxNode?
+  private var kind: PendingSyntaxKind
+  
+  private enum PendingSyntaxNodeKind {
+    /// We already have a `Syntax` node realised for this node
+    case realized(node: Syntax)
+    /// This node does not have a `Syntax` node instantiated yet. If needed, we
+    /// need to compute it from its parent RawSyntax node
+    case virtual(index: Int)
+  }
+
+  var node: Syntax {
+    switch kind {
+    case .realized(let node): return node
+    case .virtual(let index): {
+      let node = parent!.node.child(at: index)!
+      kind = .realized(node)
+      return node
+    }
+    }
+  }
+
+  var parent: PendingSyntaxNode {
+    return _parent!
+  }
+
+  init(_ root: Syntax) {
+    self.parent = nil
+    self.kind = .realized(root)
+  }
+
+  init(_ parent: PendingSyntaxNode, _ idx: Int) {
+    self.parent = parent
+    self.kind = .virtual(index: idx)
+  }
+}
+
+
 /// The raw syntax walker traverses the raw syntax tree to find
 /// node kinds the SyntaxVisitor is interested and feed these syntax nodes to
 /// SyntaxVisitor.
 /// By traversing the raw syntax tree, we avoid realizing syntax nodes that're
 /// not interesting to users' SyntaxVisitor.
 class RawSyntaxVisitor {
   private let visitor: SyntaxVisitor
-  private var childIdxChain: [Int]
-  private var nodeChain: [Syntax]
+  private var currentNode: PendingSyntaxNode
 
   required init(_ visitor: SyntaxVisitor, _ root: Syntax) {
     self.visitor = visitor
-    self.nodeChain = [root]
-    self.childIdxChain = []
-  }
-
-  convenience init(_ another: RawSyntaxVisitor, _ root: Syntax) {
-    self.init(another.visitor, root)
+    self.currentNode = PendingSyntaxNode(root)
   }
 
   func shouldVisit(_ kind: SyntaxKind) -> Bool {
@@ -169,31 +203,22 @@ class RawSyntaxVisitor {
   }
 
   func addChildIdx(_ idx: Int) {
-    childIdxChain.append(idx)
+    currentNode = PendingSyntaxNode(currentNode, idx)
   }
 
   func moveUp() {
-    if childIdxChain.isEmpty {
-      nodeChain.removeLast()
-    } else {
-      childIdxChain.removeLast()
-    }
+    currentNode = currentNode.parent
   }
 
   func visitPost() {
-    visitor.visitPost(nodeChain.last!)
+    visitor.visitPost(currentNode.node)
   }
 
   // The current raw syntax node is interesting for the user, so realize a
   // correponding syntax node and feed it into the visitor.
   func visitCurrent() -> Bool {
-    for id in childIdxChain {
-      nodeChain.append(nodeChain.last!.child(at: id)!)
-    }
-    childIdxChain.removeAll(keepingCapacity: true)
-    let node = nodeChain.last!
-    visitor.visitPre(node)
-    return visitor.visit(node)
+    visitor.visitPre(currentNode.node)
+    return visitor.visit(currentNode.node)
   }
 }