Swift Macros Deep Dive: Compile-Time Code Generation Mastery

1// #stringify - Expression'ı string'e çevirir
2let (value, code) = #stringify(2 + 3)
3// value = 5, code = "2 + 3"
4 
5// #warning ve #error - Compile-time mesajlar
6#warning("Bu kod refactor edilmeli")
7#error("Bu platform desteklenmiyor")
8 
9// Custom URL macro
10let url = #URL("https://api.example.com/users")
11// Compile-time URL validation!

1// @Observable - SwiftUI için state management
2@Observable
3class UserViewModel {
4    var name: String = ""
5    var email: String = ""
6}
7// Otomatik olarak ObservableObject uyumluluğu ekler
8 
9// @Model - SwiftData için persistence
10@Model
11class Product {
12    var name: String
13    var price: Decimal
14    var stock: Int
15}

1MyMacros/
2├── Package.swift
3├── Sources/
4│   ├── MyMacros/           # Macro declarations
5│   │   └── MyMacros.swift
6│   ├── MyMacrosImpl/       # Macro implementations
7│   │   └── MyMacrosImpl.swift
8│   └── MyMacrosClient/     # Test client
9│       └── main.swift
10└── Tests/
11    └── MyMacrosTests/

1// swift-tools-version: 5.9
2import PackageDescription
3import CompilerPluginSupport
4 
5let package = Package(
6    name: "MyMacros",
7    platforms: [.macOS(.v10_15), .iOS(.v13)],
8    products: [
9        .library(name: "MyMacros", targets: ["MyMacros"]),
10    ],
11    dependencies: [
12        .package(url: "https://github.com/apple/swift-syntax.git", from: "509.0.0"),
13    ],
14    targets: [
15        // Macro implementation
16        .macro(
17            name: "MyMacrosImpl",
18            dependencies: [
19                .product(name: "SwiftSyntaxMacros", package: "swift-syntax"),
20                .product(name: "SwiftCompilerPlugin", package: "swift-syntax"),
21            ]
22        ),
23        // Library that exposes macros
24        .target(
25            name: "MyMacros",
26            dependencies: ["MyMacrosImpl"]
27        ),
28        // Tests
29        .testTarget(
30            name: "MyMacrosTests",
31            dependencies: [
32                "MyMacrosImpl",
33                .product(name: "SwiftSyntaxMacrosTestSupport", package: "swift-syntax"),
34            ]
35        ),
36    ]
37)

1// MyMacros.swift - Macro declaration
2@attached(member, names: named(init))
3public macro AutoInit() = #externalMacro(module: "MyMacrosImpl", type: "AutoInitMacro")
4 
5// MyMacrosImpl.swift - Macro implementation
6import SwiftSyntax
7import SwiftSyntaxMacros
8import SwiftCompilerPlugin
9 
10public struct AutoInitMacro: MemberMacro {
11    public static func expansion(
12        of node: AttributeSyntax,
13        providingMembersOf declaration: some DeclGroupSyntax,
14        in context: some MacroExpansionContext
15    ) throws -> [DeclSyntax] {
16        
17        // Get stored properties
18        let properties = declaration.memberBlock.members
19            .compactMap { $0.decl.as(VariableDeclSyntax.self) }
20            .filter { $0.bindingSpecifier.tokenKind == .keyword(.var) }
21            .flatMap { $0.bindings }
22            .compactMap { binding -> (String, String)? in
23                guard let pattern = binding.pattern.as(IdentifierPatternSyntax.self),
24                      let type = binding.typeAnnotation?.type else {
25                    return nil
26                }
27                return (pattern.identifier.text, type.description.trimmingCharacters(in: .whitespaces))
28            }
29        
30        // Generate initializer
31        let parameters = properties
32            .map { "\($0.0): \($0.1)" }
33            .joined(separator: ", ")
34        
35        let assignments = properties
36            .map { "self.\($0.0) = \($0.0)" }
37            .joined(separator: "\n        ")
38        
39        let initDecl: DeclSyntax = """
40        init(\(raw: parameters)) {
41            \(raw: assignments)
42        }
43        """
44        
45        return [initDecl]
46    }
47}
48 
49@main
50struct MyMacrosPlugin: CompilerPlugin {
51    let providingMacros: [Macro.Type] = [
52        AutoInitMacro.self,
53    ]
54}

1import MyMacros
2 
3@AutoInit
4struct User {
5    var id: UUID
6    var name: String
7    var email: String
8    var age: Int
9}
10 
11// Generates:
12// init(id: UUID, name: String, email: String, age: Int) {
13//     self.id = id
14//     self.name = name
15//     self.email = email
16//     self.age = age
17// }
18 
19let user = User(id: UUID(), name: "John", email: "[email protected]", age: 30)

1@attached(member, names: named(CodingKeys), named(init(from:)), named(encode(to:)))
2@attached(extension, conformances: Codable)
3public macro EnhancedCodable() = #externalMacro(module: "MyMacrosImpl", type: "EnhancedCodableMacro")
4 
5// Usage
6@EnhancedCodable
7struct Product {
8    @CodableKey("product_name")
9    var name: String
10    
11    @CodableKey("unit_price")
12    var price: Decimal
13    
14    @CodableIgnore
15    var localCache: Data?
16}

1@freestanding(expression)
2public macro URL(_ string: String) -> URL = #externalMacro(module: "MyMacrosImpl", type: "URLMacro")
3 
4public struct URLMacro: ExpressionMacro {
5    public static func expansion(
6        of node: some FreestandingMacroExpansionSyntax,
7        in context: some MacroExpansionContext
8    ) throws -> ExprSyntax {
9        guard let argument = node.argumentList.first?.expression,
10              let stringLiteral = argument.as(StringLiteralExprSyntax.self),
11              let urlString = stringLiteral.segments.first?.as(StringSegmentSyntax.self)?.content.text else {
12            throw MacroError.invalidArgument
13        }
14        
15        // Compile-time validation
16        guard URL(string: urlString) != nil else {
17            throw MacroError.invalidURL(urlString)
18        }
19        
20        return "URL(string: \(argument))!"
21    }
22}
23 
24// Usage
25let apiURL = #URL("https://api.example.com")  // ✅ Compiles
26let badURL = #URL("not a url")  // ❌ Compile error!

1import SwiftSyntaxMacrosTestSupport
2import XCTest
3 
4final class AutoInitMacroTests: XCTestCase {
5    func testAutoInit() {
6        assertMacroExpansion(
7            """
8            @AutoInit
9            struct User {
10                var name: String
11                var age: Int
12            }
13            """,
14            expandedSource: """
15            struct User {
16                var name: String
17                var age: Int
18                init(name: String, age: Int) {
19                    self.name = name
20                    self.age = age
21                }
22            }
23            """,
24            macros: ["AutoInit": AutoInitMacro.self]
25        )
26    }
27}

1// MARK: - Custom Macro Errors
2enum MacroError: Error, DiagnosticMessage {
3    case invalidApplication(String)
4    case missingArgument(String)
5    case invalidURL(String)
6    
7    var message: String {
8        switch self {
9        case .invalidApplication(let msg): return msg
10        case .missingArgument(let arg): return "Missing argument: \(arg)"
11        case .invalidURL(let url): return "Invalid URL: \(url)"
12        }
13    }
14    
15    var diagnosticID: MessageID {
16        MessageID(domain: "MyMacros", id: String(describing: self))
17    }
18    
19    var severity: DiagnosticSeverity { .error }
20}

1import SwiftSyntaxMacrosTestSupport
2import XCTest
3 
4final class MyMacrosTests: XCTestCase {
5    let testMacros: [String: Macro.Type] = [
6        "AutoInit": AutoInitMacro.self,
7        "URL": URLMacro.self,
8    ]
9    
10    func testAutoInit_SimpleStruct() throws {
11        assertMacroExpansion(
12            """
13            @AutoInit
14            struct User {
15                var name: String
16                var age: Int
17            }
18            """,
19            expandedSource: """
20            struct User {
21                var name: String
22                var age: Int
23            
24                internal init(name: String, age: Int) {
25                    self.name = name
26                    self.age = age
27                }
28            }
29            """,
30            macros: testMacros
31        )
32    }
33}