Significantly simplify SwiftSyntaxBuilder’s implementation

This significantly simplifies the implementation of SwiftSyntaxBuilder. The main cleanups are:
- Removing the separate syntax node hierarchy in SwiftSyntaxBuilder and instead re-using the SwiftSyntax hierarchy
  - This is possible since `BasicFormat` now formats an entire SwiftSyntax tree instead of requiring the careful intraction with SwiftSyntaxBuilder’s `Buildable` types
  - All convenience intializers form SwiftSyntaxBuilder are now extensions on the SwiftSyntax nodes. We can even consider sinking them down into SwiftSyntax again
- Removing the `ExpressibleAs*` types
  - With the integration of the parser into SwiftSyntaxBuilder, you create way fewer syntax nodes explicitly. Looking at the test cases, I think the regressions on the client side aren’t too significant and this hugely simplifies the SwiftSyntaxBuilder’s implementation
  - Having written a fair amount of SwiftSyntaxBuilder code myself now, I never found the `ExpressibleAs*` protocols super useful because it was non-trivial to discover which types are expressible as other types.

Author: ahoppen

CodeGeneration/Package.swift

@@ -46,7 +46,6 @@ let package = Package(
         "Classification.swift.gyb",
         "CommonNodes.swift.gyb",
         "DeclNodes.swift.gyb",
-        "ExpressibleAsConformances.swift.gyb",
         "ExprNodes.swift.gyb",
         "GenericNodes.swift.gyb",
         "NodeSerializationCodes.swift.gyb",

CodeGeneration/Sources/SyntaxSupport/ExpressibleAsConformances.swift.gyb

@@ -10,15 +10,15 @@
 //
 //===----------------------------------------------------------------------===//
 
-public let SYNTAX_NODES: [Node] = COMMON_NODES
+public let SYNTAX_NODES: [Node] = (COMMON_NODES
   + EXPR_NODES
   + DECL_NODES
   + ATTRIBUTE_NODES
   + STMT_NODES
   + GENERIC_NODES
   + TYPE_NODES
   + PATTERN_NODES
-  + AVAILABILITY_NODES
+  + AVAILABILITY_NODES).sorted { $0.name < $1.name }
 
 /// A lookup table of nodes indexed by their kind.
 public let SYNTAX_NODE_MAP: [String: Node] = Dictionary(

CodeGeneration/Sources/SyntaxSupport/SyntaxNodes.swift

@@ -1,3 +1,2 @@
 from .utils import make_swift_child, make_swift_node
 from .BuilderInitializableTypes import BUILDER_INITIALIZABLE_TYPES
-from .ExpressibleAsConformances import SYNTAX_BUILDABLE_EXPRESSIBLE_AS_CONFORMANCES

CodeGeneration/Sources/SyntaxSupport/gyb_generated/ExpressibleAsConformances.swift

@@ -21,4 +21,13 @@ public class CodeGenerationFormat: BasicFormat {
     let formatted = super.visit(node)
     return formatted.withLeadingTrivia(indentedNewline + (formatted.leadingTrivia ?? []))
   }
+
+  public override func visit(_ node: CodeBlockItemSyntax) -> Syntax {
+    if node.parent?.parent?.is(SourceFileSyntax.self) == true, !node.item.is(ImportDeclSyntax.self) {
+      let formatted = super.visit(node)
+      return formatted.withLeadingTrivia(indentedNewline + indentedNewline + (formatted.leadingTrivia ?? []))
+    } else {
+      return super.visit(node)
+    }
+  }
 }

CodeGeneration/Sources/SyntaxSupport/gyb_helpers/ExpressibleAsConformances.py

@@ -32,18 +32,6 @@ public extension Child {
     flattened(indentedDocumentation: description ?? "")
   }
 
-  /// Generate a Swift expression that creates a proper SwiftSyntax node of type
-  /// `type.syntax` from a variable named `varName` of type `type.buildable` that
-  /// represents this child node.
-  func generateExprBuildSyntaxNode(varName: ExpressibleAsExprBuildable) -> ExpressibleAsExprBuildable {
-    if type.isToken {
-      return FunctionCallExpr(calledExpression: MemberAccessExpr(base: type.optionalChained(expr: varName), name: "buildToken"))
-    } else {
-      let expr = type.optionalChained(expr: varName)
-      return FunctionCallExpr(calledExpression: MemberAccessExpr(base: expr, name: "build\(type.baseName)"))
-    }
-  }
-
   /// If this node is a token that can't contain arbitrary text, generate a Swift
   /// `assert` statement that verifies the variable with name var_name and of type
   /// `TokenSyntax` contains one of the supported text options. Otherwise return `nil`.

CodeGeneration/Sources/SyntaxSupport/gyb_helpers/__init__.py

@@ -31,7 +31,7 @@ public extension Node {
   var documentation: String {
     let description = self.description ?? ""
     if description.isEmpty && isSyntaxCollection {
-      return "`\(syntaxKind)` represents a collection of `\(collectionElementType.buildableBaseName)`"
+      return "`\(syntaxKind)` represents a collection of `\(collectionElementType.syntaxBaseName)`"
     } else {
       return flattened(indentedDocumentation: description)
     }
@@ -51,9 +51,8 @@ public extension Node {
   }
 
   static func from(type: SyntaxBuildableType) -> Node {
-    let baseName = type.baseName
-    guard let node = SYNTAX_NODE_MAP[baseName] else {
-      fatalError("Base name \(baseName) does not have a syntax node")
+    guard let node = SYNTAX_NODE_MAP[type.syntaxKind] else {
+      fatalError("Base name \(type.syntaxKind) does not have a syntax node")
     }
     return node
   }