Merge pull request #1108 from ahoppen/ahoppen/update-codegen

Update CodeGeneration to latest SwiftSyntax version

Author: ahoppen

CodeGeneration/Package.swift

@@ -13,7 +13,7 @@ let package = Package(
     .executable(name: "generate-swiftsyntaxbuilder", targets: ["generate-swiftsyntaxbuilder"]),
   ],
   dependencies: [
-    .package(url: "https://github.com/apple/swift-syntax.git", revision: "5e9dcce1dc5c81e48b658ced23f0848be4671a0c"),
+    .package(url: "https://github.com/apple/swift-syntax.git", revision: "6e3dfb332553ad1462f0a3d45b4d91e349ce4013"),
     .package(url: "https://github.com/apple/swift-argument-parser.git", .upToNextMinor(from: "1.1.4")),
   ],
   targets: [

CodeGeneration/Sources/Utils/CodeGenerationFormat.swift

@@ -17,15 +17,27 @@ import SwiftSyntax
 public class CodeGenerationFormat: BasicFormat {
   public override var indentation: TriviaPiece { .spaces(indentationLevel * 2) }
 
+  public func ensuringTwoLeadingNewlines<NodeType: SyntaxProtocol>(node: NodeType) -> NodeType {
+    if node.leadingTrivia?.first?.isNewline ?? false {
+      return node.withLeadingTrivia(indentedNewline + (node.leadingTrivia ?? []))
+    } else {
+      return node.withLeadingTrivia(indentedNewline + indentedNewline + (node.leadingTrivia ?? []))
+    }
+  }
+
   public override func visit(_ node: MemberDeclListItemSyntax) -> MemberDeclListItemSyntax {
     let formatted = super.visit(node)
-    return formatted.withLeadingTrivia(indentedNewline + (formatted.leadingTrivia ?? []))
+    if node.indexInParent != 0 {
+      return ensuringTwoLeadingNewlines(node: formatted)
+    } else {
+      return formatted
+    }
   }
 
   public override func visit(_ node: CodeBlockItemSyntax) -> CodeBlockItemSyntax {
     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 ?? []))
+      return ensuringTwoLeadingNewlines(node: formatted)
     } else {
       return super.visit(node)
     }

CodeGeneration/Sources/Utils/SyntaxBuildableChild.swift

@@ -35,7 +35,7 @@ public extension Child {
   }
 
   var parameterType: Type {
-    return self.type.optionalWrapped(type: Type(parameterBaseType))
+    return self.type.optionalWrapped(type: SimpleTypeIdentifier(name: .identifier(parameterBaseType)))
   }
 
   /// If the child node has documentation associated with it, return it as single
@@ -74,7 +74,7 @@ public extension Child {
     }
     for textChoice in choices {
       assertChoices.append(Expr(SequenceExpr {
-        MemberAccessExpr(base: type.forceUnwrappedIfNeeded(expr: Expr(varName)), name: "text")
+        MemberAccessExpr(base: type.forceUnwrappedIfNeeded(expr: IdentifierExpr(identifier: .identifier(varName))), name: "text")
         BinaryOperatorExpr(text: "==")
         StringLiteralExpr(content: textChoice)
       }))

CodeGeneration/Sources/Utils/SyntaxBuildableType.swift

@@ -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: Type(shorthandName))
+    optionalWrapped(type: SimpleTypeIdentifier(name: .identifier(shorthandName)))
   }
 
   /// Whether parameters of this type should be initializable by a result builder.
@@ -126,7 +126,7 @@ public struct SyntaxBuildableType: Hashable {
   /// which will eventually get built from `SwiftSyntaxBuilder`. If the type
   /// is optional, this terminates with a `?`.
   public var syntax: TypeSyntax {
-    return optionalWrapped(type: TypeSyntax(syntaxBaseName))
+    return optionalWrapped(type: SimpleTypeIdentifier(name: .identifier(syntaxBaseName)))
   }
 
   /// The type that is used for paramters in SwiftSyntaxBuilder that take this
@@ -140,7 +140,7 @@ public struct SyntaxBuildableType: Hashable {
   }
 
   public var parameterType: TypeSyntax {
-    return optionalWrapped(type: TypeSyntax(parameterBaseType))
+    return optionalWrapped(type: SimpleTypeIdentifier(name: .identifier(parameterBaseType)))
   }
 
   /// Assuming that this is a collection type, the non-optional type of the result builder
@@ -165,7 +165,7 @@ public struct SyntaxBuildableType: Hashable {
   }
 
   /// Wraps a type in an optional depending on whether `isOptional` is true.
-  public func optionalWrapped(type: TypeSyntaxProtocol) -> TypeSyntax {
+  public func optionalWrapped<TypeNode: TypeSyntaxProtocol>(type: TypeNode) -> TypeSyntax {
     if isOptional {
       return TypeSyntax(OptionalType(wrappedType: type))
     } else {

CodeGeneration/Sources/generate-swiftbasicformat/BasicFormatFile.swift

@@ -80,7 +80,7 @@ let basicFormatFile = SourceFile {
       SwitchStmt(expression: Expr("keyPath")) {
         for node in SYNTAX_NODES where !node.isBase {
           for child in node.children where child.isIndented {
-            SwitchCase("case \\\(node.type.syntaxBaseName).\(child.swiftName):") {
+            SwitchCase("case \\\(raw: node.type.syntaxBaseName).\(raw: child.swiftName):") {
               ReturnStmt("return true")
             }
           }
@@ -95,7 +95,7 @@ let basicFormatFile = SourceFile {
       SwitchStmt(expression: Expr("keyPath")) {
         for node in SYNTAX_NODES where !node.isBase {
           for child in node.children where child.requiresLeadingNewline {
-            SwitchCase("case \\\(node.type.syntaxBaseName).\(child.swiftName):") {
+            SwitchCase("case \\\(raw: node.type.syntaxBaseName).\(raw: child.swiftName):") {
               ReturnStmt("return true")
             }
           }
@@ -110,7 +110,7 @@ let basicFormatFile = SourceFile {
       SwitchStmt(expression: Expr("node.as(SyntaxEnum.self)")) {
         for node in SYNTAX_NODES where !node.isBase {
           if node.elementsSeparatedByNewline {
-            SwitchCase("case .\(node.swiftSyntaxKind):") {
+            SwitchCase("case .\(raw: node.swiftSyntaxKind):") {
               ReturnStmt("return true")
             }
           }
@@ -125,7 +125,7 @@ let basicFormatFile = SourceFile {
       SwitchStmt(expression: Expr("tokenKind")) {
         for token in SYNTAX_TOKENS {
           if token.requiresLeadingSpace {
-            SwitchCase("case .\(token.swiftKind):") {
+            SwitchCase("case .\(raw: token.swiftKind):") {
               ReturnStmt("return true")
             }
           }
@@ -140,7 +140,7 @@ let basicFormatFile = SourceFile {
       SwitchStmt(expression: Expr("tokenKind")) {
         for token in SYNTAX_TOKENS {
           if token.requiresTrailingSpace {
-            SwitchCase("case .\(token.swiftKind):") {
+            SwitchCase("case .\(raw: token.swiftKind):") {
               ReturnStmt("return true")
             }
           }
@@ -178,7 +178,7 @@ private func createChildVisitCall(childType: SyntaxBuildableType, rewrittenExpr:
   }
   if childType.baseType?.baseName != "Syntax", childType.baseType?.isSyntaxCollection != true, childType.baseType != nil {
     let optionalChained = childType.optionalChained(expr: visitCall)
-    return FunctionCallExpr("\(optionalChained).cast(\(childType.syntaxBaseName).self)")
+    return FunctionCallExpr("\(optionalChained).cast(\(raw: childType.syntaxBaseName).self)")
   } else {
     return visitCall
   }
@@ -193,7 +193,7 @@ private func makeSyntaxCollectionRewriteFunc(node: Node) -> FunctionDecl {
     let formattedChildrenVarLet = node.elementsSeparatedByNewline ? "var" : "let"
     VariableDecl(
       """
-      \(formattedChildrenVarLet) formattedChildren = node.map {
+      \(raw: formattedChildrenVarLet) formattedChildren = node.map {
         \(createChildVisitCall(childType: node.collectionElementType, rewrittenExpr: IdentifierExpr(identifier: .dollarIdentifier("$0"))))
       }
       """
@@ -211,7 +211,7 @@ private func makeSyntaxCollectionRewriteFunc(node: Node) -> FunctionDecl {
         """
       )
     }
-    ReturnStmt("return \(node.type.syntaxBaseName)(formattedChildren)")
+    ReturnStmt("return \(raw: node.type.syntaxBaseName)(formattedChildren)")
   }
 }
 

CodeGeneration/Sources/generate-swiftideutils/SyntaxClassificationFile.swift

@@ -32,7 +32,7 @@ var node_child_classifications: [ChildClassification] {
 let syntaxClassificationFile = SourceFile {
   ImportDecl(
     """
-    \(generateCopyrightHeader(for: "generate-ideutils"))
+    \(raw: generateCopyrightHeader(for: "generate-ideutils"))
     @_spi(RawSyntax) import SwiftSyntax
     """
   )
@@ -41,8 +41,8 @@ let syntaxClassificationFile = SourceFile {
     for classification in SYNTAX_CLASSIFICATIONS {
       EnumCaseDecl(
         """
-        /// \(classification.description)
-        case \(classification.swiftName)
+        /// \(raw: classification.description)
+        case \(raw: classification.swiftName)
         """
       )
     }
@@ -70,8 +70,8 @@ let syntaxClassificationFile = SourceFile {
           ) {
             SwitchStmtSyntax(expression: ExprSyntax("(parentKind, indexInParent)")) {
               for childClassification in node_child_classifications where childClassification.isToken {
-                SwitchCaseSyntax("case (.\(childClassification.parent.swiftSyntaxKind), \(childClassification.childIndex)):") {
-                  ReturnStmt("return (.\(childClassification.classification!.swiftName), \(childClassification.force))")
+                SwitchCaseSyntax("case (.\(raw: childClassification.parent.swiftSyntaxKind), \(raw: childClassification.childIndex)):") {
+                  ReturnStmt("return (.\(raw: childClassification.classification!.swiftName), \(raw: childClassification.force))")
                 }
               }
 
@@ -80,8 +80,8 @@ let syntaxClassificationFile = SourceFile {
           } elseBody: {
             SwitchStmtSyntax(expression: ExprSyntax("(parentKind, indexInParent)")) {
               for childClassification in node_child_classifications where !childClassification.isToken {
-                SwitchCaseSyntax("case (.\(childClassification.parent.swiftSyntaxKind), \(childClassification.childIndex)):") {
-                    ReturnStmt("return (.\(childClassification.classification!.swiftName), \(childClassification.force))")
+                SwitchCaseSyntax("case (.\(raw: childClassification.parent.swiftSyntaxKind), \(raw: childClassification.childIndex)):") {
+                  ReturnStmt("return (.\(raw: childClassification.classification!.swiftName), \(raw: childClassification.force))")
                 }
               }
 
@@ -98,9 +98,9 @@ let syntaxClassificationFile = SourceFile {
       type: TypeAnnotation(type: TypeSyntax("SyntaxClassification"))) {
         SwitchStmt(expression: ExprSyntax("self")) {
           for token in SYNTAX_TOKENS {
-            SwitchCaseSyntax("case .\(token.swiftKind):") {
+            SwitchCaseSyntax("case .\(raw: token.swiftKind):") {
               if let classification = token.classification {
-                ReturnStmt("return .\(classification.swiftName)")
+                ReturnStmt("return .\(raw: classification.swiftName)")
               } else {
                 ReturnStmt("return .none)")
               }

CodeGeneration/Sources/generate-swiftsyntaxbuilder/BuildableCollectionNodesFile.swift

@@ -33,7 +33,7 @@ let buildableCollectionNodesFile = SourceFile {
         InitializerDecl(
           """
           public init(_ elements: \(ArrayType(elementType: elementType.parameterType))) {
-            self = \(node.type.syntaxBaseName)(elements.map { \(elementType.syntax)(fromProtocol: $0) })
+            self = \(raw: node.type.syntaxBaseName)(elements.map { \(elementType.syntax)(fromProtocol: $0) })
           }
           """
         )

CodeGeneration/Sources/generate-swiftsyntaxbuilder/BuildableNodesFile.swift

@@ -28,7 +28,7 @@ let buildableNodesFile = SourceFile {
     let docComment: SwiftSyntax.Trivia = node.documentation.isEmpty ? [] : .docLineComment("/// \(node.documentation)") + .newline
     ExtensionDecl(
       leadingTrivia: docComment,
-      extendedType: Type(type.shorthandName),
+      extendedType: SimpleTypeIdentifier(name: .identifier(type.shorthandName)),
       inheritanceClause: hasTrailingComma ? TypeInheritanceClause { InheritedType(typeName: Type("HasTrailingComma")) } : nil
     ) {
       // Generate initializers
@@ -61,9 +61,9 @@ let buildableNodesFile = SourceFile {
 
 private func convertFromSyntaxProtocolToSyntaxType(child: Child) -> Expr {
   if child.type.isBaseType && child.nodeChoices.isEmpty {
-    return Expr(FunctionCallExpr("\(child.type.syntaxBaseName)(fromProtocol: \(child.swiftName))"))
+    return Expr(FunctionCallExpr("\(raw: child.type.syntaxBaseName)(fromProtocol: \(raw: child.swiftName))"))
   } else {
-    return Expr(IdentifierExpr(child.swiftName))
+    return Expr(IdentifierExpr(identifier: .identifier(child.swiftName)))
   }
 }
 
@@ -104,7 +104,7 @@ private func createDefaultInitializer(node: Node) -> InitializerDecl {
         assertStmt
       }
     }
-    let nodeConstructorCall = FunctionCallExpr(callee: type.syntaxBaseName) {
+    let nodeConstructorCall = FunctionCallExpr(callee: Expr(IdentifierExpr(identifier: .identifier(type.syntaxBaseName)))) {
       for child in node.children {
         TupleExprElement(
           label: child.isUnexpectedNodes ? nil : child.swiftName,
@@ -141,12 +141,12 @@ private func createConvenienceInitializer(node: Node) -> InitializerDecl? {
       if child.type.builderInitializableType != child.type {
         let param = Node.from(type: child.type).singleNonDefaultedChild
         if child.isOptional {
-          produceExpr = Expr(FunctionCallExpr("\(child.swiftName)Builder().map { \(child.type.syntaxBaseName)(\(param.swiftName): $0) }"))
+          produceExpr = Expr(FunctionCallExpr("\(raw: child.swiftName)Builder().map { \(raw: child.type.syntaxBaseName)(\(raw: param.swiftName): $0) }"))
         } else {
-          produceExpr = Expr(FunctionCallExpr("\(child.type.syntaxBaseName)(\(param.swiftName): \(child.swiftName)Builder())"))
+          produceExpr = Expr(FunctionCallExpr("\(raw: child.type.syntaxBaseName)(\(raw: param.swiftName): \(raw: child.swiftName)Builder())"))
         }
       } else {
-        produceExpr = Expr(FunctionCallExpr("\(child.swiftName)Builder()"))
+        produceExpr = Expr(FunctionCallExpr("\(raw: child.swiftName)Builder()"))
       }
       let defaultArgument = ClosureExpr {
         if child.type.isOptional {
@@ -163,11 +163,11 @@ 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.\(token.swiftKind.withFirstCharacterLowercased.backticked)")
+      let tokenExpr = MemberAccessExpr("Token.\(raw: token.swiftKind.withFirstCharacterLowercased.backticked)")
       if child.type.isOptional {
-        produceExpr = Expr(FunctionCallExpr("\(child.swiftName).map { \(tokenExpr)($0) }"))
+        produceExpr = Expr(FunctionCallExpr("\(raw: child.swiftName).map { \(tokenExpr)($0) }"))
       } else {
-        produceExpr = Expr(FunctionCallExpr("\(tokenExpr)(\(child.swiftName))"))
+        produceExpr = Expr(FunctionCallExpr("\(tokenExpr)(\(raw: child.swiftName))"))
       }
       normalParameters.append(FunctionParameter("\(child.swiftName): \(paramType)", for: .functionParameters))
     } else {

CodeGeneration/Sources/generate-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: \(elementChoice)) -> Self.Component {
+            public static func buildExpression(_ expression: \(raw: elementChoice)) -> Self.Component {
               return buildExpression(.init(expression))
             }
             """
@@ -168,8 +168,8 @@ let resultBuildersFile = SourceFile {
 
     ExtensionDecl(
       """
-      public extension \(type.shorthandName) {
-        init(@\(type.resultBuilderBaseName) itemsBuilder: () -> \(type.shorthandName)) {
+      public extension \(raw: type.shorthandName) {
+        init(@\(raw: type.resultBuilderBaseName) itemsBuilder: () -> \(raw: type.shorthandName)) {
           self = itemsBuilder()
         }
       }

CodeGeneration/Sources/generate-swiftsyntaxbuilder/TokenFile.swift

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