Move Format to a separate package

This way we can use `Format` to format Fix-Its in the parser

Author: ahoppen

Code-Generation/Package.swift

@@ -8,19 +8,32 @@ let package = Package(
       .macOS(.v10_15),
     ],
   products: [
+    .executable(name: "generate-swiftbasicformat", targets: ["generate-swiftbasicformat"]),
     .executable(name: "generate-swiftsyntaxbuilder", targets: ["generate-swiftsyntaxbuilder"]),
   ],
   dependencies: [
     .package(url: "https://github.com/apple/swift-syntax.git", revision: "dcd692d759e09730098e45ba7276d0d96d004bac"),
     .package(url: "https://github.com/apple/swift-argument-parser.git", .upToNextMinor(from: "1.1.4")),
   ],
   targets: [
+    .executableTarget(
+      name: "generate-swiftbasicformat",
+      dependencies: [
+        .product(name: "SwiftSyntax", package: "swift-syntax"),
+        .product(name: "SwiftSyntaxBuilder", package: "swift-syntax"),
+        .product(name: "ArgumentParser", package: "swift-argument-parser"),
+        "SyntaxSupport",
+        "Utils"
+      ]
+    ),
     .executableTarget(
       name: "generate-swiftsyntaxbuilder",
       dependencies: [
+        .product(name: "SwiftSyntax", package: "swift-syntax"),
         .product(name: "SwiftSyntaxBuilder", package: "swift-syntax"),
         .product(name: "ArgumentParser", package: "swift-argument-parser"),
-        "SyntaxSupport"
+        "SyntaxSupport",
+        "Utils"
       ]
     ),
     .target(
@@ -46,5 +59,13 @@ let package = Package(
         "TypeNodes.swift.gyb"
       ]
     ),
+    .target(
+      name: "Utils",
+      dependencies: [
+        .product(name: "SwiftSyntax", package: "swift-syntax"),
+        .product(name: "SwiftSyntaxBuilder", package: "swift-syntax"),
+        "SyntaxSupport"
+      ]
+    ),
   ]
 )

Code-Generation/Sources/generate-swiftsyntaxbuilder/String+Extensions.swift renamed to Code-Generation/Sources/Utils/String+Extensions.swift

@@ -12,7 +12,7 @@
 
 import Foundation
 
-extension StringProtocol {
+public extension StringProtocol {
     var withFirstCharacterLowercased: String { prefix(1).lowercased() + dropFirst() }
     var withFirstCharacterUppercased: String { prefix(1).uppercased() + dropFirst() }
     var backticked: String { "`\(self)`" }

Code-Generation/Sources/generate-swiftsyntaxbuilder/SyntaxBuildableChild.swift renamed to Code-Generation/Sources/Utils/SyntaxBuildableChild.swift

@@ -16,7 +16,7 @@ import SyntaxSupport
 
 /// Extension to the `Child` type to provide functionality specific to
 /// SwiftSyntaxBuilder.
-extension Child {
+public extension Child {
   /// The type of this child, represented by a `SyntaxBuildableType`, which can
   /// be used to create the corresponding `Buildable` and `ExpressibleAs` types.
   var type: SyntaxBuildableType {

Code-Generation/Sources/generate-swiftsyntaxbuilder/SyntaxBuildableNode.swift renamed to Code-Generation/Sources/Utils/SyntaxBuildableNode.swift

@@ -14,7 +14,7 @@ import SyntaxSupport
 
 /// Extension to the `Node` type to provide functionality specific to
 /// SwiftSyntaxBuilder.
-extension Node {
+public extension Node {
   /// The node's syntax kind as `SyntaxBuildableType`.
   var type: SyntaxBuildableType {
     SyntaxBuildableType(syntaxKind: syntaxKind)

Code-Generation/Sources/generate-swiftsyntaxbuilder/SyntaxBuildableType.swift renamed to Code-Generation/Sources/Utils/SyntaxBuildableType.swift

@@ -18,31 +18,31 @@ import SyntaxSupport
 /// SwiftSyntaxBuilder. In particular, this includes the functionality to create
 /// the `*Buildable`, `ExpressibleAs*` and `*Syntax` Swift types from the syntax
 /// kind.
-struct SyntaxBuildableType: Hashable {
-  let syntaxKind: String
-  let tokenKind: String?
-  let isOptional: Bool
+public struct SyntaxBuildableType: Hashable {
+  public let syntaxKind: String
+  public let tokenKind: String?
+  public let isOptional: Bool
 
   /// Whether this is a token.
-  var isToken: Bool {
+  public var isToken: Bool {
     syntaxKind == "Token"
   }
 
   /// This type with `isOptional` set to false.
-  var nonOptional: Self {
+  public var nonOptional: Self {
     tokenKind.map { Self(syntaxKind: $0) } ?? Self(syntaxKind: syntaxKind)
   }
 
   /// The token if this is a token.
-  var token: TokenSpec? {
+  public var token: TokenSpec? {
     tokenKind.flatMap { SYNTAX_TOKEN_MAP[$0] }
   }
 
   /// If the type has a default value (because it is optional or a token
   /// with fixed test), return an expression of the form ` = defaultValue`
   /// that can be used as the default value for a function parameter.
   /// Otherwise, return the empty string.
-  var defaultInitialization: ExpressibleAsExprBuildable? {
+  public var defaultInitialization: ExpressibleAsExprBuildable? {
     if isOptional {
       return NilLiteralExpr()
     } else if isToken {
@@ -56,14 +56,14 @@ struct SyntaxBuildableType: Hashable {
   }
 
   /// Whether the type is a syntax collection.
-  var isSyntaxCollection: Bool {
+  public var isSyntaxCollection: Bool {
     syntaxKind == "SyntaxCollection"
       || (baseType.map(\.isSyntaxCollection) ?? false)
   }
 
   /// The raw base name of this kind. Used for the `build*` methods in the
   /// defined in the buildable types.
-  var baseName: String {
+  public var baseName: String {
     syntaxKind
   }
 
@@ -75,20 +75,20 @@ struct SyntaxBuildableType: Hashable {
   ///  - For base kinds: `<BaseKind>Buildable`, e.g. `ExprBuildable` (these are implemented as protocols)
   ///  - For token: `TokenSyntax` (tokens don't have a dedicated type in SwiftSyntaxBuilder)
   /// If the type is optional, the type is wrapped in an `OptionalType`.
-  var buildable: ExpressibleAsTypeBuildable {
+  public var buildable: ExpressibleAsTypeBuildable {
     optionalWrapped(type: buildableBaseName)
   }
 
   /// Whether parameters of this type should be initializable by a result builder.
   /// Used for certain syntax collections and block-like structures (e.g. `CodeBlock`,
   /// `MemberDeclList`).
-  var isBuilderInitializable: Bool {
+  public var isBuilderInitializable: Bool {
     BUILDER_INITIALIZABLE_TYPES.keys.contains(buildableBaseName)
   }
 
   /// A type suitable for initializing this type through a result builder (e.g.
   /// returns `CodeBlockItemList` for `CodeBlock`) and otherwise itself.
-  var builderInitializableType: Self {
+  public var builderInitializableType: Self {
     Self(
       syntaxKind: BUILDER_INITIALIZABLE_TYPES[buildableBaseName].flatMap { $0 } ?? buildableBaseName,
       isOptional: isOptional
@@ -97,7 +97,7 @@ struct SyntaxBuildableType: Hashable {
 
   /// The type from `buildable()` without any question marks attached.
   /// This is used for the `create*` methods defined in the `ExpressibleAs*` protocols.
-  var buildableBaseName: String {
+  public var buildableBaseName: String {
     if SYNTAX_BASE_KINDS.contains(syntaxKind) {
       return "\(syntaxKind)Buildable"
     } else {
@@ -107,7 +107,7 @@ struct SyntaxBuildableType: Hashable {
 
   /// The `ExpressibleAs*` Swift type for this syntax kind without any
   /// question marks attached.
-  var expressibleAsBaseName: String {
+  public var expressibleAsBaseName: String {
     if isToken {
       // Tokens don't have a dedicated ExpressibleAs type.
       return buildableBaseName
@@ -119,13 +119,13 @@ struct SyntaxBuildableType: Hashable {
   /// The `ExpressibleAs*` Swift type for this syntax kind. Tokens don't
   /// have an `ExpressibleAs*` type, so for those this method just returns
   /// `TokenSyntax`. If the type is optional, this terminates with a `?`.
-  var expressibleAs: ExpressibleAsTypeBuildable {
+  public var expressibleAs: ExpressibleAsTypeBuildable {
     optionalWrapped(type: expressibleAsBaseName)
   }
 
   /// The corresponding `*Syntax` type defined in the `SwiftSyntax` module,
   /// without any question marks attached.
-  var syntaxBaseName: String {
+  public var syntaxBaseName: String {
     if syntaxKind == "Syntax" {
       return "Syntax"
     } else {
@@ -136,60 +136,60 @@ struct SyntaxBuildableType: Hashable {
   /// The corresponding `*Syntax` type defined in the `SwiftSyntax` module,
   /// which will eventually get built from `SwiftSyntaxBuilder`. If the type
   /// is optional, this terminates with a `?`.
-  var syntax: ExpressibleAsTypeBuildable {
+  public var syntax: ExpressibleAsTypeBuildable {
     optionalWrapped(type: syntaxBaseName)
   }
 
   /// Assuming that this is a base kind, return the corresponding `*ListBuildable` type
   /// without any question marks attached.
-  var listBuildableBaseName: String {
+  public var listBuildableBaseName: String {
     assert(SYNTAX_BASE_KINDS.contains(syntaxKind), "ListBuildable types only exist for syntax base kinds")
     return "\(syntaxKind)ListBuildable"
   }
 
   /// Assuming that this is a base kind, return the corresponding `*ListBuildable` type.
-  var listBuildable: ExpressibleAsTypeBuildable {
+  public var listBuildable: ExpressibleAsTypeBuildable {
     optionalWrapped(type: listBuildableBaseName)
   }
 
   /// Assuming that this is a collection type, the non-optional type of the result builder
   /// that can be used to build the collection.
-  var resultBuilderBaseName: String {
+  public var resultBuilderBaseName: String {
     "\(syntaxKind)Builder"
   }
 
   /// Assuming that this is a collection type, the type of the result builder
   /// that can be used to build the collection.
-  var resultBuilder: ExpressibleAsTypeBuildable {
+  public var resultBuilder: ExpressibleAsTypeBuildable {
     optionalWrapped(type: resultBuilderBaseName)
   }
 
   /// The collection types in which this type occurs as an element.
   /// We automatically make the `ExpressibleAs*` protocols conform to the
   /// `ExpressibleAs*` protocol of the collection they occur in.
-  var elementInCollections: [Self] {
+  public var elementInCollections: [Self] {
     SYNTAX_NODES
       .filter { $0.isSyntaxCollection && $0.collectionElementType == self }
       .map { $0.type }
   }
 
   /// Whether this type has the `WithTrailingComma` trait.
-  var hasWithTrailingCommaTrait: Bool {
+  public var hasWithTrailingCommaTrait: Bool {
     SYNTAX_NODES.contains { $0.type == self && $0.traits.contains("WithTrailingComma") }
   }
 
   /// Types that take a single non-optional parameter of this types
   /// and to which this type is thus convertible. We automatically
   /// make the `ExpressibleAs*` of this type conform to the `ExpressibleAs*`
   /// protocol of the convertible types.
-  var convertibleToTypes: [Self] {
+  public var convertibleToTypes: [Self] {
     (SYNTAX_BUILDABLE_EXPRESSIBLE_AS_CONFORMANCES[buildableBaseName] ?? [])
       .map { Self(syntaxKind: $0) }
   }
 
   /// If this type is not a base kind, its base type (see `SyntaxBuildableNode.base_type()`),
   /// otherwise `nil`.
-  var baseType: Self? {
+  public var baseType: Self? {
     if !SYNTAX_BASE_KINDS.contains(syntaxKind) && !isToken {
       return Node.from(type: self).baseType
     } else {
@@ -199,7 +199,7 @@ struct SyntaxBuildableType: Hashable {
 
   /// The types to which this `ExpressibleAs*` type conforms to via
   /// automatically generated conformances.
-  var generatedExpressibleAsConformances: [Self] {
+  public var generatedExpressibleAsConformances: [Self] {
     var conformances = elementInCollections + convertibleToTypes
     if let baseType = baseType, baseType.baseName != "SyntaxCollection" {
       conformances.append(baseType)
@@ -209,7 +209,7 @@ struct SyntaxBuildableType: Hashable {
 
   /// The types to which this `ExpressibleAs*` type conforms to via
   /// automatically generated conformances, including transitive conformances.
-  var transitiveExpressibleAsConformances: [Self] {
+  public var transitiveExpressibleAsConformances: [Self] {
     generatedExpressibleAsConformances.flatMap { conformance in
       [conformance] + conformance.transitiveExpressibleAsConformances
     }
@@ -218,13 +218,13 @@ struct SyntaxBuildableType: Hashable {
   /// The types to which this `ExpressibleAs*` type implicitly conforms
   /// to via transitive conformances. These conformances don't need to be
   /// spelled out explicitly in the source code.
-  var impliedExpressibleAsConformances: [Self] {
+  public var impliedExpressibleAsConformances: [Self] {
     generatedExpressibleAsConformances.flatMap { conformance in
       conformance.transitiveExpressibleAsConformances
     }
   }
 
-  init(syntaxKind: String, isOptional: Bool = false) {
+  public init(syntaxKind: String, isOptional: Bool = false) {
     self.isOptional = isOptional
     if syntaxKind.hasSuffix("Token") {
       // There are different token kinds but all of them are represented by `Token` in the Swift source (see `kind_to_type` in `gyb_syntax_support`).
@@ -237,7 +237,7 @@ struct SyntaxBuildableType: Hashable {
   }
 
   /// Wraps a type in an optional depending on whether `isOptional` is true.
-  func optionalWrapped(type: ExpressibleAsTypeBuildable) -> ExpressibleAsTypeBuildable {
+  public func optionalWrapped(type: ExpressibleAsTypeBuildable) -> ExpressibleAsTypeBuildable {
     if isOptional {
       return OptionalType(wrappedType: type)
     } else {
@@ -246,7 +246,7 @@ struct SyntaxBuildableType: Hashable {
   }
 
   /// Wraps a type in an optional chaining depending on whether `isOptional` is true.
-  func optionalChained(expr: ExpressibleAsExprBuildable) -> ExpressibleAsExprBuildable {
+  public func optionalChained(expr: ExpressibleAsExprBuildable) -> ExpressibleAsExprBuildable {
     if isOptional {
       return OptionalChainingExpr(expression: expr)
     } else {
@@ -255,7 +255,7 @@ struct SyntaxBuildableType: Hashable {
   }
 
   /// Wraps a type in a force unwrap expression depending on whether `isOptional` is true.
-  func forceUnwrappedIfNeeded(expr: ExpressibleAsExprBuildable) -> ExpressibleAsExprBuildable {
+  public func forceUnwrappedIfNeeded(expr: ExpressibleAsExprBuildable) -> ExpressibleAsExprBuildable {
     if isOptional {
       return ForcedValueExpr(expression: expr)
     } else {
@@ -265,7 +265,7 @@ struct SyntaxBuildableType: Hashable {
 
   /// Generate an expression that converts a variable named `varName`
   /// which is of `expressibleAs` type to an object of type `buildable`.
-  func generateExprConvertParamTypeToStorageType(varName: String) -> ExpressibleAsExprBuildable {
+  public func generateExprConvertParamTypeToStorageType(varName: String) -> ExpressibleAsExprBuildable {
     if isToken {
       return varName
     } else {

Code-Generation/Sources/generate-swiftsyntaxbuilder/Utils.swift renamed to Code-Generation/Sources/Utils/Utils.swift

@@ -13,19 +13,19 @@
 import Foundation
 
 /// Trims leading and trailing whitespace from each line.
-func dedented<Lines: Sequence>(lines: Lines) -> [String] where Lines.Element: StringProtocol {
+public func dedented<Lines: Sequence>(lines: Lines) -> [String] where Lines.Element: StringProtocol {
   lines.map { $0.trimmingCharacters(in: .whitespacesAndNewlines) }
 }
 
 /// Trims leading and trailing whitespace from each line.
-func dedented(string: String) -> String {
+public func dedented(string: String) -> String {
   dedented(lines: string.split(separator: "\n"))
     .joined(separator: "\n")
 }
 
 /// Creates a single-line documentation string from indented
 /// documentation as written in `gyb_syntax_support`.
-func flattened(indentedDocumentation: String) -> String {
+public func flattened(indentedDocumentation: String) -> String {
   dedented(string: indentedDocumentation)
     .replacingOccurrences(of: "\n", with: "")
     .trimmingCharacters(in: .whitespacesAndNewlines)

Code-Generation/Sources/generate-swiftsyntaxbuilder/FormatFile.swift renamed to Code-Generation/Sources/generate-swiftbasicformat/FormatFile.swift

@@ -13,6 +13,8 @@
 import Foundation
 import SwiftSyntax
 import SwiftSyntaxBuilder
+import SyntaxSupport
+import Utils
 
 let formatFile = SourceFile {
   ImportDecl(
@@ -136,6 +138,7 @@ private func createFormatFunctionSignature(type: SyntaxBuildableType) -> Functio
 /// Generate the format implementation for a buildable node.
 private func createBuildableNodeFormatFunction(node: Node) -> FunctionDecl {
   FunctionDecl(
+    modifiers: Token.public,
     identifier: .identifier("format"),
     signature: createFormatFunctionSignature(type: node.type)
   ) {
@@ -191,6 +194,7 @@ private func createBuildableNodeFormatFunction(node: Node) -> FunctionDecl {
 /// The implementation updates the leading trivia of the elements with their indentation.
 private func createBuildableCollectionNodeFormatFunction(node: Node) -> FunctionDecl {
   FunctionDecl(
+    modifiers: Token.public,
     identifier: .identifier("format"),
     signature: createFormatFunctionSignature(type: node.type)
   ) {
@@ -229,6 +233,7 @@ private func createBuildableCollectionNodeFormatFunction(node: Node) -> Function
 private func createTokenFormatFunction() -> FunctionDecl {
   let tokenType = SyntaxBuildableType(syntaxKind: "Token")
   return FunctionDecl(
+    modifiers: Token.public,
     identifier: .identifier("format"),
     signature: createFormatFunctionSignature(type: tokenType)
   ) {