Remove the typealiases in SwiftSyntaxBuilder that refer to syntax nodes without the Syntax suffix

In the past, before SwiftSyntaxBuilder shared the same syntax nodes with SwiftSyntax, it made sense for it to have its own syntax nodes and thus drop the `Syntax` suffix.

But since SwiftSyntaxBuilder is now just providing convenience initializers, it’s confusing to have two names to refer to the same type - the style was already pretty inconsitent in this code base. To make things consistent, drop the typealiases.

Author: ahoppen

CodeGeneration/Sources/Utils/SyntaxBuildableType.swift

@@ -58,9 +58,9 @@ public struct SyntaxBuildableType: Hashable {
       return Expr(NilLiteralExpr())
     } else if isToken {
       if let token = token, token.text != nil {
-        return Expr(MemberAccessExpr(base: "Token", name: lowercaseFirstWord(name: token.name).backticked))
+        return Expr(MemberAccessExpr(base: "TokenSyntax", name: lowercaseFirstWord(name: token.name).backticked))
       } else if tokenKind == "EOFToken" {
-        return Expr(MemberAccessExpr(base: "Token", name: "eof"))
+        return Expr(MemberAccessExpr(base: "TokenSyntax", name: "eof"))
       }
     }
     return nil
@@ -87,7 +87,7 @@ public struct SyntaxBuildableType: Hashable {
   ///  - For token: `TokenSyntax` (tokens don't have a dedicated type in SwiftSyntaxBuilder)
   /// If the type is optional, the type is wrapped in an `OptionalType`.
   public var buildable: Type {
-    optionalWrapped(type: SimpleTypeIdentifier(name: .identifier(shorthandName)))
+    optionalWrapped(type: SimpleTypeIdentifier(name: .identifier(syntaxBaseName)))
   }
 
   /// Whether parameters of this type should be initializable by a result builder.
@@ -101,17 +101,11 @@ public struct SyntaxBuildableType: Hashable {
   /// returns `CodeBlockItemList` for `CodeBlock`) and otherwise itself.
   public var builderInitializableType: Self {
     Self(
-      syntaxKind: BUILDER_INITIALIZABLE_TYPES[shorthandName].flatMap { $0 } ?? shorthandName,
+      syntaxKind: BUILDER_INITIALIZABLE_TYPES[syntaxKind].flatMap { $0 } ?? syntaxKind,
       isOptional: isOptional
     )
   }
 
-  /// The type name without the `Syntax`. `SwiftSyntaxBuilder` declares typealiases
-  /// that map these to the corresponding `*Syntax` nodes.
-  public var shorthandName: String {
-    return syntaxKind
-  }
-
   /// The corresponding `*Syntax` type defined in the `SwiftSyntax` module,
   /// without any question marks attached.
   public var syntaxBaseName: String {
@@ -135,7 +129,7 @@ public struct SyntaxBuildableType: Hashable {
     if isBaseType {
       return "\(syntaxBaseName)Protocol"
     } else {
-      return shorthandName
+      return syntaxBaseName
     }
   }
 

CodeGeneration/Sources/generate-swiftsyntax/GenerateSwiftSyntax.swift

@@ -64,7 +64,6 @@ struct GenerateSwiftSyntax: ParsableCommand {
       TemplateSpec(sourceFile: resultBuildersFile, module: swiftSyntaxBuilderDir, filename: "ResultBuilders.swift"),
       TemplateSpec(sourceFile: syntaxExpressibleByStringInterpolationConformancesFile, module: swiftSyntaxBuilderDir, filename: "SyntaxExpressibleByStringInterpolationConformances.swift"),
       TemplateSpec(sourceFile: tokenFile, module: swiftSyntaxBuilderDir, filename: "Token.swift"),
-      TemplateSpec(sourceFile: typealiasesFile, module: swiftSyntaxBuilderDir, filename: "Typealiases.swift"),
     ]
 
     var errors: [Error] = []

CodeGeneration/Sources/generate-swiftsyntax/templates/swiftsyntaxbuilder/BuildableCollectionNodesFile.swift

@@ -27,7 +27,7 @@ let buildableCollectionNodesFile = SourceFile {
 
     let docComment = node.documentation.isEmpty ? "" : "/// \(node.documentation)\n"
     // Generate collection node struct
-    ExtensionDecl("\(docComment)extension \(node.type.shorthandName): ExpressibleByArrayLiteral") {
+    ExtensionDecl("\(docComment)extension \(node.type.syntaxBaseName): ExpressibleByArrayLiteral") {
       // Generate initializers
       if elementType.isBaseType && node.collectionElementChoices?.isEmpty ?? true {
         InitializerDecl(

CodeGeneration/Sources/generate-swiftsyntax/templates/swiftsyntaxbuilder/BuildableNodesFile.swift

@@ -30,7 +30,7 @@ let buildableNodesFile = SourceFile {
       let docComment: SwiftSyntax.Trivia = node.documentation.isEmpty ? [] : .docLineComment("/// \(node.documentation)") + .newline
       ExtensionDecl(
         leadingTrivia: docComment,
-        extendedType: SimpleTypeIdentifier(name: .identifier(type.shorthandName)),
+        extendedType: SimpleTypeIdentifier(name: .identifier(type.syntaxBaseName)),
         inheritanceClause: hasTrailingComma ? TypeInheritanceClause { InheritedType(typeName: Type("HasTrailingComma")) } : nil
       ) {
         if let convenienceInit = convenienceInit {
@@ -113,7 +113,7 @@ private func createConvenienceInitializer(node: Node) -> InitializerDecl? {
       // Allow initializing identifiers and other tokens without default text with a String
       shouldCreateInitializer = true
       let paramType = child.type.optionalWrapped(type: Type("String"))
-      let tokenExpr = MemberAccessExpr("Token.\(raw: token.swiftKind.withFirstCharacterLowercased.backticked)")
+      let tokenExpr = MemberAccessExpr("TokenSyntax.\(raw: token.swiftKind.withFirstCharacterLowercased.backticked)")
       if child.type.isOptional {
         produceExpr = Expr(FunctionCallExpr("\(raw: child.swiftName).map { \(tokenExpr)($0) }"))
       } else {

CodeGeneration/Sources/generate-swiftsyntax/templates/swiftsyntaxbuilder/ResultBuildersFile.swift

@@ -78,7 +78,7 @@ let resultBuildersFile = SourceFile {
             """
             /// If declared, provides contextual type information for statement
             /// expressions to translate them into partial results.
-            public static func buildExpression(_ expression: \(raw: elementChoice)) -> Self.Component {
+            public static func buildExpression(_ expression: \(raw: elementChoice)Syntax) -> Self.Component {
               return buildExpression(.init(expression))
             }
             """
@@ -168,8 +168,8 @@ let resultBuildersFile = SourceFile {
 
     ExtensionDecl(
       """
-      public extension \(raw: type.shorthandName) {
-        init(@\(raw: type.resultBuilderBaseName) itemsBuilder: () -> \(raw: type.shorthandName)) {
+      public extension \(raw: type.syntaxBaseName) {
+        init(@\(raw: type.resultBuilderBaseName) itemsBuilder: () -> \(raw: type.syntaxBaseName)) {
           self = itemsBuilder()
         }
       }

CodeGeneration/Sources/generate-swiftsyntax/templates/swiftsyntaxbuilder/TokenFile.swift

@@ -26,7 +26,7 @@ let tokenFile = SourceFile {
       if token.isKeyword {
         VariableDecl("""
           /// The `\(raw: token.text!)` keyword
-          static var \(raw: token.name.withFirstCharacterLowercased.backticked): Token {
+          static var \(raw: token.name.withFirstCharacterLowercased.backticked): TokenSyntax {
             return .\(raw: token.swiftKind)()
           }
           """