Move SyntaxAnyVisitor.swift, SyntaxBaseNodes.swift gyb files to codegen

Author: kimdv

CodeGeneration/Sources/SyntaxSupport/Child.swift

@@ -119,3 +119,21 @@ public class Child {
     }
   }
 }
+
+extension Child: Equatable {
+  public static func == (lhs: Child, rhs: Child) -> Bool {
+    return lhs.name == rhs.name &&
+      lhs.syntaxKind == rhs.syntaxKind &&
+      lhs.description == rhs.description &&
+      lhs.collectionElementName == rhs.collectionElementName &&
+      lhs.forceClassification == rhs.forceClassification &&
+      lhs.isIndented == rhs.isIndented &&
+      lhs.requiresLeadingNewline == rhs.requiresLeadingNewline &&
+      lhs.isOptional == rhs.isOptional &&
+      lhs.textChoices == rhs.textChoices &&
+      lhs.nodeChoices == rhs.nodeChoices  &&
+      lhs.classification == rhs.classification &&
+      lhs.tokenChoices == rhs.tokenChoices &&
+      lhs.tokenCanContainArbitraryText == rhs.tokenCanContainArbitraryText
+  }
+}

CodeGeneration/Sources/SyntaxSupport/Classification.swift.gyb

@@ -34,6 +34,12 @@ public class SyntaxClassification {
   }
 }
 
+extension SyntaxClassification: Equatable {
+  public static func == (lhs: SyntaxClassification, rhs: SyntaxClassification) -> Bool {
+    return lhs.name == rhs.name && lhs.description == rhs.description
+  }
+}
+
 public class ChildClassification {
   public let parent: Node
   public let childIndex: Int

CodeGeneration/Sources/SyntaxSupport/Node.swift

@@ -73,6 +73,10 @@ public class Node {
     return syntaxKind.contains("Token") || collectionElement.contains("Token")
   }
 
+  public var isVisitable: Bool {
+    return !isBase
+  }
+  
   init(name: String,
        nameForDiagnostics: String?,
        description: String? = nil,
@@ -137,3 +141,23 @@ public class Node {
     assert(!isSyntaxCollection || elementName != nil || element != "")
   }
 }
+
+extension Node: Equatable {
+  public static func == (lhs: Node, rhs: Node) -> Bool {
+    return lhs.syntaxKind == rhs.syntaxKind &&
+      lhs.swiftSyntaxKind == rhs.swiftSyntaxKind &&
+      lhs.name == rhs.name &&
+      lhs.nameForDiagnostics == rhs.nameForDiagnostics &&
+      lhs.description == rhs.description &&
+      lhs.baseKind == rhs.baseKind &&
+      lhs.parserFunction == rhs.parserFunction &&
+      lhs.traits == rhs.traits &&
+      lhs.children == rhs.children &&
+      lhs.nonUnexpectedChildren == rhs.nonUnexpectedChildren &&
+      lhs.collectionElementName == rhs.collectionElementName &&
+      lhs.collectionElementChoices == rhs.collectionElementChoices &&
+      lhs.omitWhenEmpty == rhs.omitWhenEmpty &&
+      lhs.elementsSeparatedByNewline == rhs.elementsSeparatedByNewline &&
+      lhs.collectionElement == rhs.collectionElement
+  }
+}

CodeGeneration/Sources/SyntaxSupport/TokenSpec.swift.gyb

@@ -67,6 +67,20 @@ public class TokenSpec {
   }
 }
 
+extension TokenSpec: Equatable {
+  public static func == (lhs: TokenSpec, rhs: TokenSpec) -> Bool {
+    return lhs.name == rhs.name &&
+      lhs.kind == rhs.kind &&
+      lhs.nameForDiagnostics == rhs.nameForDiagnostics &&
+      lhs.unprefixedKind == rhs.unprefixedKind &&
+      lhs.text == rhs.text &&
+      lhs.classification == rhs.classification &&
+      lhs.isKeyword == rhs.isKeyword &&
+      lhs.requiresLeadingSpace == rhs.requiresLeadingSpace &&
+      lhs.requiresTrailingSpace == rhs.requiresTrailingSpace
+  }
+}
+
 /// Represents a keyword token.
 public class KeywordSpec: TokenSpec {
   init(

CodeGeneration/Sources/SyntaxSupport/gyb_generated/Classification.swift

@@ -27,6 +27,12 @@ public class SyntaxClassification {
   }
 }
 
+extension SyntaxClassification: Equatable {
+  public static func == (lhs: SyntaxClassification, rhs: SyntaxClassification) -> Bool {
+    return lhs.name == rhs.name && lhs.description == rhs.description
+  }
+}
+
 public class ChildClassification {
   public let parent: Node
   public let childIndex: Int

CodeGeneration/Sources/SyntaxSupport/gyb_generated/TokenSpec.swift

@@ -61,6 +61,20 @@ public class TokenSpec {
   }
 }
 
+extension TokenSpec: Equatable {
+  public static func == (lhs: TokenSpec, rhs: TokenSpec) -> Bool {
+    return lhs.name == rhs.name &&
+      lhs.kind == rhs.kind &&
+      lhs.nameForDiagnostics == rhs.nameForDiagnostics &&
+      lhs.unprefixedKind == rhs.unprefixedKind &&
+      lhs.text == rhs.text &&
+      lhs.classification == rhs.classification &&
+      lhs.isKeyword == rhs.isKeyword &&
+      lhs.requiresLeadingSpace == rhs.requiresLeadingSpace &&
+      lhs.requiresTrailingSpace == rhs.requiresTrailingSpace
+  }
+}
+
 /// Represents a keyword token.
 public class KeywordSpec: TokenSpec {
   init(

CodeGeneration/Sources/generate-swiftsyntax/GenerateSwiftSyntax.swift

@@ -27,6 +27,8 @@ struct GenerateSwiftSyntax: ParsableCommand {
     try generateTemplates(
       templates: [
         (miscFile, "Misc.swift"),
+        (syntaxAnyVisitorFile, "SyntaxAnyVisitor.swift"),
+        (syntaxBaseNodesFile, "SyntaxBaseNodes.swift"),
       ],
       destination: URL(fileURLWithPath: generatedPath),
       verbose: verbose

CodeGeneration/Sources/generate-swiftsyntax/SyntaxAnyVisitorFile.swift

@@ -0,0 +1,85 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2022 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+import SwiftSyntax
+import SwiftSyntaxBuilder
+import SyntaxSupport
+import Utils
+
+let syntaxAnyVisitorFile = SourceFile {
+  ClassDecl("""
+    \(generateCopyrightHeader(for: "generate-swiftsyntax"))
+    
+    /// A `SyntaxVisitor` that can visit the nodes as generic `Syntax` values.
+    ///
+    /// This subclass of `SyntaxVisitor` is slower than the type-specific visitation
+    /// of `SyntaxVisitor`. Use `SyntaxAnyVisitor` if the `visitAny(_)` function
+    /// would be useful to have, otherwise inherit from `SyntaxVisitor`.
+    ///
+    /// This works by overriding the type-specific visit function that delegate to
+    /// `visitAny(_)`. A subclass that provides a custom type-specific visit
+    /// function, should also call `visitAny(_)` in its implementation, if calling
+    /// `visitAny` is needed:
+    ///
+    ///     struct MyVisitor: SyntaxAnyVisitor {
+    ///       func visitAny(_ node: Syntax) -> SyntaxVisitorContinueKind {
+    ///         <code>
+    ///       }
+    ///
+    ///       func visit(_ token: TokenSyntax) -> SyntaxVisitorContinueKind {
+    ///         <code>
+    ///         // Call this to pass tokens to `visitAny(_)` as well if needed
+    ///         visitAny(token)
+    ///       }
+    open class SyntaxAnyVisitor: SyntaxVisitor
+    """) {
+    FunctionDecl("""
+      open func visitAny(_ node: Syntax) -> SyntaxVisitorContinueKind {
+        return .visitChildren
+      }
+      """)
+    
+    FunctionDecl("""
+      /// The function called after visiting the node and its descendents.
+      ///   - node: the node we just finished visiting.
+      open func visitAnyPost(_ node: Syntax) {}
+      """)
+    
+    FunctionDecl("""
+      // MARK: Override type specific visit methods
+
+      override open func visit(_ token: TokenSyntax) -> SyntaxVisitorContinueKind {
+        return visitAny(token._syntaxNode)
+      }
+      """)
+
+    FunctionDecl("""
+      override open func visitPost(_ node: TokenSyntax) {
+        visitAnyPost(node._syntaxNode)
+      }
+      """)
+
+    for node in SYNTAX_NODES where node.isVisitable {
+      FunctionDecl("""
+        override open func visit(_ node: \(raw: node.name)) -> SyntaxVisitorContinueKind {
+          return visitAny(node._syntaxNode)
+        }
+        """)
+      
+      FunctionDecl("""
+        override open func visitPost(_ node: \(raw: node.name)) {
+          visitAnyPost(node._syntaxNode)
+        }
+        """)
+    }
+  }
+}