initial

Author: tib

.gitignore

@@ -0,0 +1,4 @@
+.DS_Store
+.swiftpm
+.build
+.vscode

Package.resolved

@@ -0,0 +1,58 @@
+// swift-tools-version: 5.9
+import CompilerPluginSupport
+import PackageDescription
+
+let package = Package(
+    name: "swift-macros",
+    platforms: [
+        .macOS(.v12),
+    ],
+    products: [
+        .executable(
+            name: "Examples",
+            targets: ["Examples"]
+        ),
+        .library(
+            name: "SwiftMacros",
+            targets: ["SwiftMacros"]
+        ),
+    ],
+    dependencies: [
+        .package(
+            url: "https://github.com/apple/swift-syntax.git",
+            branch: "main"
+        ),
+    ],
+    targets: [
+        .macro(
+            name: "SwiftMacrosPlugin",
+            dependencies: [
+                .product(name: "SwiftSyntax", package: "swift-syntax"),
+                .product(name: "SwiftSyntaxMacros", package: "swift-syntax"),
+                .product(name: "SwiftOperators", package: "swift-syntax"),
+                .product(name: "SwiftParser", package: "swift-syntax"),
+                .product(name: "SwiftParserDiagnostics", package: "swift-syntax"),
+                .product(name: "SwiftCompilerPlugin", package: "swift-syntax"),
+            ]
+        ),
+        .target(
+            name: "SwiftMacros",
+            dependencies: [
+                "SwiftMacrosPlugin"
+            ]
+        ),
+        .executableTarget(
+            name: "Examples",
+            dependencies: [
+                "SwiftMacros"
+            ]
+        ),
+        .testTarget(
+            name: "SwiftMacrosTests",
+            dependencies: [
+                "SwiftMacrosPlugin"
+            ]
+        )
+    ]
+)
+

Package.swift

@@ -0,0 +1,38 @@
+# SwiftMacros
+
+🚧 A collection of useful macro definitions for Swift. (WIP)
+
+
+## Getting started
+
+Just use the following dependency to your project.
+
+```swift
+.package(url: "https://github.com/binarybirds/swift-macros", branch: "main"),
+```
+
+Don't forget to add the `SwiftMacros` product to your target.
+```
+.product(name: "SwiftMacros", package: "swift-macros"),
+```
+
+## Useful macros
+
+### Init
+
+Generates a public init for objects.
+
+```swift
+import Foundation
+import SwiftMacros
+
+@Init
+public struct Something: Codable {
+    let foo: String
+    let bar: Int
+    let hello: Bool?
+
+}
+```
+
+That's all for now.

README.md

@@ -0,0 +1,10 @@
+import Foundation
+import SwiftMacros
+
+@Init
+public struct Something: Codable {
+    let foo: String
+    let bar: Int
+    let hello: Bool?
+
+}

Sources/Examples/main.swift

@@ -0,0 +1,7 @@
+import Foundation
+
+@attached(member, names: named(init))
+public macro Init() = #externalMacro(
+    module: "SwiftMacrosPlugin",
+    type: "InitMacro"
+)

Sources/SwiftMacros/SwiftMacros.swift

@@ -0,0 +1,48 @@
+import SwiftSyntax
+import SwiftSyntaxMacros
+
+public struct InitMacro: MemberMacro {
+    
+    public static func expansion<Declaration, Context>(
+        of node: AttributeSyntax,
+        providingMembersOf declaration: Declaration,
+        in context: Context
+    ) throws -> [SwiftSyntax.DeclSyntax] where Declaration : DeclGroupSyntax, Context : MacroExpansionContext {
+
+        let members = declaration.memberBlock.members
+        
+        var props: [(name: String, type: String)] = []
+        for member in members {
+            guard
+                let v = member.decl.as(VariableDeclSyntax.self),
+                let b = v.bindings.first,
+                let i = b.pattern.as(IdentifierPatternSyntax.self),
+                let t = b.typeAnnotation?.type
+            else {
+                continue
+            }
+            let n = i.identifier.text
+            let tv = t.description
+           
+            props.append((name: n, type: tv))
+        }
+
+        let parameters = props
+            .map { "\($0.name): \($0.type)"}
+            .joined(separator: ",\n")
+        
+        let assignments = props
+            .map { "self.\($0.name) = \($0.name)"}
+            .joined(separator: "\n")
+        
+        return [
+            """
+            public init(
+                \(raw: parameters)
+            ) {
+                \(raw: assignments)
+            }
+            """
+        ]
+    }
+}

Sources/SwiftMacrosPlugin/Macros/InitMacro.swift

@@ -0,0 +1,12 @@
+#if canImport(SwiftCompilerPlugin)
+import SwiftCompilerPlugin
+import SwiftSyntaxMacros
+
+@main
+struct SwiftMacrosPlugin: CompilerPlugin {
+    
+    let providingMacros: [Macro.Type] = [
+        InitMacro.self,
+    ]
+}
+#endif

Sources/SwiftMacrosPlugin/SwiftMacrosPlugin.swift

@@ -0,0 +1,54 @@
+import XCTest
+import SwiftSyntax
+import SwiftSyntaxBuilder
+import SwiftSyntaxMacros
+import SwiftMacrosPlugin
+
+final class SwiftMacrosTests: XCTestCase {
+
+    let testMacros: [String: Macro.Type] = [
+        "Init": InitMacro.self,
+    ]
+
+    func testInitMacro() throws {
+
+        let sf: SourceFileSyntax = """
+        @Init
+        public struct Something: Codable {
+            let foo: String
+            let bar: Int
+            let hello: Bool?
+        }
+        """
+        
+        let expectation = """
+        
+        public struct Something: Codable {
+            let foo: String
+            let bar: Int
+            let hello: Bool?
+            public init(
+                foo: String,
+            bar: Int,
+            hello: Bool?
+            ) {
+                self.foo = foo
+            self.bar = bar
+            self.hello = hello
+            }
+        }
+        """
+
+        let context = BasicMacroExpansionContext(
+            sourceFiles: [
+                sf: .init(
+                    moduleName: "TestModule",
+                    fullFilePath: "test.swift"
+                )
+            ]
+        )
+
+        let transformed = sf.expand(macros: testMacros, in: context)
+        XCTAssertEqual(transformed.formatted().description, expectation)
+    }
+}