Update CodeGeneration to latest SwiftSyntax version

This updates the version lock of CodeGeneration to the latest SwiftSyntax version.

CodeGeneration still relies quite a bit on raw string interpolation. I’m hoping that we can remove some of these if we stop generating the node definitions using gyb and can thus improve the underlying data structure in the SyntaxSupport module.

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()
           }
           """
         )

CodeGeneration/Sources/generate-swiftsyntaxbuilder/TypealiasesFile.swift

@@ -25,6 +25,6 @@ let typealiasesFile = SourceFile {
   TypealiasDecl("public typealias Token = TokenSyntax")
 
   for node in SYNTAX_NODES where !node.isUnknown && !node.isMissing {
-    TypealiasDecl("public typealias \(node.type.shorthandName) = \(node.type.syntaxBaseName)")
+    TypealiasDecl("public typealias \(raw: node.type.shorthandName) = \(raw: node.type.syntaxBaseName)")
   }
 }

Sources/IDEUtils/generated/SyntaxClassification.swift

@@ -19,40 +19,58 @@
 public enum SyntaxClassification {
   /// The token should not receive syntax coloring.
   case none
+  
   /// A Swift keyword, including contextual keywords.
   case keyword
+  
   /// A generic identifier.
   case identifier
+  
   /// An identifier referring to a type.
   case typeIdentifier
+  
   /// An identifier referring to an operator.
   case operatorIdentifier
+  
   /// An identifier starting with `$` like `$0`.
   case dollarIdentifier
+  
   /// An integer literal.
   case integerLiteral
+  
   /// A floating point literal.
   case floatingLiteral
+  
   /// A string literal including multiline string literals.
   case stringLiteral
+  
   /// The opening and closing parenthesis of string interpolation.
   case stringInterpolationAnchor
+  
   /// A `#` keyword like `#warning`.
   case poundDirectiveKeyword
+  
   /// A build configuration directive like `#if`, `#elseif`, `#else`.
   case buildConfigId
+  
   /// An attribute starting with an `@`.
   case attribute
+  
   /// An image, color, etc. literal.
   case objectLiteral
+  
   /// An editor placeholder of the form `<#content#>`
   case editorPlaceholder
+  
   /// A line comment starting with `//`.
   case lineComment
+  
   /// A doc line comment starting with `///`.
   case docLineComment
+  
   /// A block comment starting with `/**` and ending with `*/.
   case blockComment
+  
   /// A doc block comment starting with `/**` and ending with `*/.
   case docBlockComment
 }