Support iOS 15/macOS 12 (#50)

* Update StringGenerator to produce APIs that work on WWDC21 OS releases

* Make implementation details of generated Localizable struct private

* Refactor generator and create SwiftSyntax extensions

* Update snapshots

* Make BundleDescription type fileprivate

* Restore documentation

Sources/StringGenerator/SwiftSyntax/AttributeSyntax+Availability.swift

@@ -29,6 +29,24 @@ extension AvailabilityArgumentListSyntax {
             AvailabilityArgumentSyntax(argument: .token(.binaryOperator("*")))
         ]
     }
+
+    static var wwdc2021: AvailabilityArgumentListSyntax {
+        [
+            AvailabilityArgumentSyntax(argument: .platformVersionRestriction("macOS", versionMajor: 12))
+                .with(\.trailingComma, .commaToken()),
+
+            AvailabilityArgumentSyntax(argument: .platformVersionRestriction("iOS", versionMajor: 15))
+                .with(\.trailingComma, .commaToken()),
+
+            AvailabilityArgumentSyntax(argument: .platformVersionRestriction("tvOS", versionMajor: 15))
+                .with(\.trailingComma, .commaToken()),
+
+            AvailabilityArgumentSyntax(argument: .platformVersionRestriction("watchOS", versionMajor: 8))
+                .with(\.trailingComma, .commaToken()),
+
+            AvailabilityArgumentSyntax(argument: .token(.binaryOperator("*")))
+        ]
+    }
 }
 
 extension PlatformVersionSyntax {

Sources/StringGenerator/SwiftSyntax/ExtensionDeclSyntax.swift

@@ -0,0 +1,33 @@
+import SwiftSyntax
+import SwiftSyntaxBuilder
+
+extension ExtensionDeclSyntax {
+    init(
+        availability: AvailabilityArgumentListSyntax,
+        accessLevel: Keyword? = nil,
+        extendedType: some TypeSyntaxProtocol,
+        @MemberBlockItemListBuilder memberBlockBuilder: () -> MemberBlockItemListSyntax
+    ) {
+        self.init(
+            attributes: [
+                .attribute(
+                    AttributeSyntax(availability: availability)
+                        .with(\.trailingTrivia, .newline)
+                )
+            ],
+            modifiers: DeclModifierListSyntax {
+                if let accessLevel {
+                    DeclModifierSyntax(name: .keyword(accessLevel))
+                }
+            },
+            extendedType: extendedType,
+            memberBlock: MemberBlockSyntax(members: memberBlockBuilder())
+        )
+    }
+
+    func spacingMembers(_ lineCount: Int = 2) -> ExtensionDeclSyntax {
+        updating(\.memberBlock) { memberBlock in
+            memberBlock = memberBlock.spacingMembers(lineCount)
+        }
+    }
+}

Sources/StringGenerator/SwiftSyntax/FunctionCallExprSyntax.swift

@@ -0,0 +1,22 @@
+import SwiftSyntax
+import SwiftSyntaxBuilder
+
+extension FunctionCallExprSyntax {
+    func multiline() -> FunctionCallExprSyntax {
+        self
+            .updating(\.arguments) { arguments in
+                arguments = LabeledExprListSyntax {
+                    for (idx, argument) in zip(1..., arguments) {
+                        if idx == arguments.count {
+                            argument.with(\.leadingTrivia, .newline)
+                        } else {
+                            argument
+                                .with(\.trailingComma, .commaToken())
+                                .with(\.leadingTrivia, .newline)
+                        }
+                    }
+                }
+            }
+            .with(\.rightParen, .rightParenToken(leadingTrivia: .newline))
+    }
+}

Sources/StringGenerator/SwiftSyntax/FunctionSignatureSyntax.swift

@@ -0,0 +1,38 @@
+import SwiftSyntax
+import SwiftSyntaxBuilder
+
+extension FunctionSignatureSyntax {
+    func multiline() -> FunctionSignatureSyntax {
+        self
+            .updating(\.parameterClause) { $0 = $0.multiline() }
+    }
+}
+
+extension FunctionParameterClauseSyntax {
+    func multiline() -> FunctionParameterClauseSyntax {
+        self
+            .updating(\.parameters) { parameters in
+                parameters = FunctionParameterListSyntax {
+                    for parameter in parameters {
+                        parameter.with(\.leadingTrivia, .newline)
+                    }
+                }
+            }
+            .with(\.rightParen, .rightParenToken(leadingTrivia: .newline))
+    }
+
+    func commaSeparated() -> FunctionParameterClauseSyntax {
+        self.updating(\.parameters) { parameters in
+            parameters = FunctionParameterListSyntax {
+                for (idx, parameter) in zip(1..., parameters) {
+                    if idx == parameters.count {
+                        parameter
+                    } else {
+                        parameter
+                            .with(\.trailingComma, .commaToken())
+                    }
+                }
+            }
+        }
+    }
+}

Sources/StringGenerator/SwiftSyntax/MemberBlockSyntax.swift

@@ -0,0 +1,17 @@
+import SwiftSyntax
+
+extension MemberBlockSyntax {
+    func spacingMembers(_ lineCount: Int = 2) -> MemberBlockSyntax {
+        updating(\.members) { members in
+            members = MemberBlockItemListSyntax {
+                for (idx, item) in zip(1..., members) {
+                    if idx == members.count {
+                        item
+                    } else {
+                        item.with(\.trailingTrivia, .newlines(lineCount))
+                    }
+                }
+            }
+        }
+    }
+}

Sources/StringGenerator/SwiftSyntax/SourceFileSyntax.swift

@@ -0,0 +1,18 @@
+import SwiftSyntax
+
+extension SourceFileSyntax {
+    func spacingStatements(_ lineCount: Int = 2) -> Self {
+        var copy = self
+        copy.statements = CodeBlockItemListSyntax {
+            for (idx, item) in zip(1..., statements) {
+                if idx == statements.count {
+                    item
+                } else {
+                    item.with(\.trailingTrivia, .newlines(lineCount))
+                }
+            }
+        }
+        return copy
+    }
+}
+

Sources/StringGenerator/SwiftSyntax/StructDeclSyntax.swift

@@ -0,0 +1,9 @@
+import SwiftSyntax
+
+extension StructDeclSyntax {
+    func spacingMembers(_ lineCount: Int = 2) -> StructDeclSyntax {
+        updating(\.memberBlock) { memberBlock in
+            memberBlock = memberBlock.spacingMembers(lineCount)
+        }
+    }
+}

Sources/StringGenerator/SwiftSyntax/SyntaxProtocol.swift

@@ -0,0 +1,10 @@
+import SwiftSyntax
+
+public extension SyntaxProtocol {
+    /// Returns a new syntax node that has the child at `keyPath` updated by the changes closure
+    func updating<T>(_ keyPath: WritableKeyPath<Self, T>, changes: (inout T) -> Void) -> Self {
+        var copy = self
+        changes(&copy[keyPath: keyPath])
+        return copy
+    }
+}

Sources/StringGenerator/SwiftSyntax/TokenSyntax+Import.swift

@@ -0,0 +1,11 @@
+import SwiftSyntax
+
+extension TokenSyntax {
+    enum Import: String {
+        case Foundation = "Foundation"
+    }
+
+    static func `import`(_ value: Import) -> TokenSyntax {
+        .identifier(value.rawValue)
+    }
+}

Sources/StringGenerator/SwiftSyntax/TokenSyntax+Types.swift

@@ -0,0 +1,24 @@
+import SwiftSyntax
+
+extension TokenSyntax {
+    enum MetaType: String {
+        case String
+        case StaticString
+        case LocalizationValue
+        case Locale
+        case Bundle
+        case AnyClass
+        case BundleDescription
+        case LocalizedStringResource
+    }
+
+    static func type(_ value: MetaType) -> TokenSyntax {
+        .identifier(value.rawValue)
+    }
+}
+
+extension TypeSyntaxProtocol where Self == IdentifierTypeSyntax {
+    static func identifier(_ value: TokenSyntax.MetaType) -> IdentifierTypeSyntax {
+        IdentifierTypeSyntax(name: .type(value))
+    }
+}

Tests/PluginTests/PluginTests.swift

@@ -7,6 +7,10 @@ final class PluginTests: XCTestCase {
             String(localized: .localizable.demoBasic),
             "A basic string"
         )
+        XCTAssertEqual(
+            String(localizable: .demoBasic),
+            "A basic string"
+        )
 
         XCTAssertEqual(
             String(localized: .localizable.multiline(2)),
@@ -15,15 +19,30 @@ final class PluginTests: XCTestCase {
             spans 2 lines
             """
         )
+        XCTAssertEqual(
+            String(localizable: .multiline(2)),
+            """
+            A string that
+            spans 2 lines
+            """
+        )
 
         XCTAssertEqual(
             String(localized: .featureOne.pluralExample(1)),
             "1 string remaining"
         )
+        XCTAssertEqual(
+            String(featureOne: .pluralExample(1)),
+            "1 string remaining"
+        )
 
         XCTAssertEqual(
             String(localized: .featureOne.pluralExample(10)),
             "10 strings remaining"
         )
+        XCTAssertEqual(
+            String(featureOne: .pluralExample(10)),
+            "10 strings remaining"
+        )
     }
 }