[SwiftSyntax] Add SyntaxRewriter.visitAny(_:) (#15212)

* [SwiftSyntax] Add SyntaxRewriter.visitAny(_:)

This function, when overridden, allows Syntax rewriters to perform custom dynamic visitation behavior. If a user wanted to, say, store a series of transformations accessible by metatype, they can override visitAny and do their own runtime dispatch.

If a non-nil result is returned from visitAny, the original specialized visitors are skipped.

Author: harlanhaskins

test/SwiftSyntax/Inputs/near-empty.swift

@@ -0,0 +1 @@
+n

test/SwiftSyntax/VisitorTest.swift

@@ -53,4 +53,28 @@ VisitorTests.test("RewritingNodeWithEmptyChild") {
   })
 }
 
+VisitorTests.test("SyntaxRewriter.visitAny") {
+  class VisitAnyRewriter: SyntaxRewriter {
+    let transform: (TokenSyntax) -> TokenSyntax
+    init(transform: @escaping (TokenSyntax) -> TokenSyntax) {
+      self.transform = transform
+    }
+    override func visitAny(_ node: Syntax) -> Syntax? {
+      if let tok = node as? TokenSyntax {
+        return transform(tok)
+      }
+      return nil
+    }
+  }
+  expectDoesNotThrow({
+    let parsed = try SourceFileSyntax.decodeSourceFileSyntax(try
+      SwiftLang.parse(getInput("near-empty.swift")))
+    let rewriter = VisitAnyRewriter(transform: { _ in
+       return SyntaxFactory.makeIdentifier("")
+    })
+    let rewritten = rewriter.visit(parsed)
+    expectEqual(rewritten.description, "")
+  })
+}
+
 runAllTests()

tools/SwiftSyntax/SyntaxRewriter.swift.gyb

@@ -45,13 +45,28 @@ open class SyntaxRewriter {
   ///   - node: the node we are about to visit.
   open func visitPre(_ node: Syntax) {}
 
+  /// Override point to choose custom visitation dispatch instead of the
+  /// specialized `visit(_:)` methods. Use this instead of those methods if
+  /// you intend to dynamically dispatch rewriting behavior.
+  /// - note: If this method returns a non-nil result, the specialized
+  ///         `visit(_:)` methods will not be called for this node.
+  open func visitAny(_ node: Syntax) -> Syntax? {
+    return nil
+  }
+
   /// The function called after visting the node and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: Syntax) {}
 
   public func visit(_ node: Syntax) -> Syntax {
     visitPre(node)
     defer { visitPost(node) }
+
+    // If the global visitor returned non-nil, skip specialized dispatch.
+    if let newNode = visitAny(node) {
+      return newNode
+    }
+
     switch node.raw.kind {
     case .token: return visit(node as! TokenSyntax)
 % for node in SYNTAX_NODES: