🔥 매크로 구현

// swift-tools-version: 5.9
 
import PackageDescription
import CompilerPluginSupport
 
let package = Package(
    name: "MyPackage",
    platforms: [ .iOS(.v17), .macOS(.v13)],
    // ...
)
swift복사

targets: [
    // 소스 변환을 수행하는 매크로 구현
    .macro(
        name: "MyProjectMacros",
        dependencies: [
            .product(name: "SwiftSyntaxMacros", package: "swift-syntax"),
            .product(name: "SwiftCompilerPlugin", package: "swift-syntax")
        ]
    ),
 
    // 매크로를 API의 일부로 노출하는 라이브러리
    .target(name: "MyProject", dependencies: ["MyProjectMacros"]),
]
swift복사

dependencies: [
    .package(url: "<https://github.com/apple/swift-syntax>", from: "509.0.0")
],
swift복사

import SwiftSyntax
import SwiftSyntaxMacros
 
public struct FourCharacterCode: ExpressionMacro {
    public static func expansion(
        of node: some FreestandingMacroExpansionSyntax,
        in context: some MacroExpansionContext
    ) throws -> ExprSyntax {
        guard let argument = node.argumentList.first?.expression,
              let segments = argument.as(StringLiteralExprSyntax.self)?.segments,
              segments.count == 1,
              case .stringSegment(let literalSegment)? = segments.first
        else {
            throw CustomError.message("Need a static string")
        }
 
        let string = literalSegment.content.text
        guard let result = fourCharacterCode(for: string) else {
            throw CustomError.message("Invalid four-character code")
        }
 
        return "\(raw: result) as UInt32"
    }
}
 
private func fourCharacterCode(for characters: String) -> UInt32? {
    guard characters.count == 4 else { return nil }
 
    var result: UInt32 = 0
    for character in characters {
        result = result << 8
        guard let asciiValue = character.asciiValue else { return nil }
        result += UInt32(asciiValue)
    }
    return result
}
enum CustomError: Error { case message(String) }
swift복사

public struct FourCharacterCode: ExpressionMacro {
swift복사

public static func expansion(
    of node: some FreestandingMacroExpansionSyntax,
    in context: some MacroExpansionContext
) throws -> ExprSyntax {
swift복사

guard let argument = node.argumentList.first?.expression,
      let segments = argument.as(StringLiteralExprSyntax.self)?.segments,
      segments.count == 1,
      case .stringSegment(let literalSegment)? = segments.first
else {
    throw CustomError.message("Need a static string")
}
swift복사

let string = literalSegment.content.text
guard let result = fourCharacterCode(for: string) else {
    throw CustomError.message("Invalid four-character code")
}
swift복사

return "\(raw: result) as UInt32"
swift복사

import SwiftCompilerPlugin
 
@main
struct MyProjectMacros: CompilerPlugin {
    var providingMacros: [Macro.Type] = [FourCharacterCode.self]
}
swift복사