[Swift] WWDC 2023 - Write Swift macros 매크로 #1

안녕하세요!
조금 늦은 감이 있지만, Swift 5.9에서부터 제공하기 시작한 macro에 대해 공부해 보고자
WWDC 23 - Write Swift macros 세션을 듣고 정리해 보았습니다.

 

---

 

Swift의 macro를 사용하면 기존의 반복되는 코드를 컴파일타임에 생성하여, 개발 생산성을 높여준다.

Overview

let calculations = [
    ( 1 + 1, "1 + 1" ),
    ( 2 + 3, "2 + 3" ),
    ( 7 - 3, "7 - 3" ),
    ( 5 - 2, "5 - 2" ),
    ( 3 * 2, "3 * 2" ),
    ( 3 * 5, "3 * 5" )
]

이렇게 학생들이 계산 능력을 연습하는 데 사용할 수 있는 계산 목록이 있다.
tuple의 왼쪽에는 정수형 결과가 표시되고, tuple의 오른쪽에는 계산식이 문자열로 나타난다.



이때, 2가지의 문제점이 발생한다.

• tuple에 대한 내용인 (결과, 계산식)을 개발자가 수기로 입력하고 있기 때문에, 결과와 식이 맞지 않을 수 있다.
• 값 도출을 위해선, 반복적이고 중복적인 코드 작성이 필요하다.

하지만, Swift 5.9에서는 macro를 정의하여 이 작업을 간소화할 수 있다!

 

let calculations = [
    #stringify(1 + 1),
    #stringify(2 + 3),
    #stringify(7 - 3),
    #stringify(5 - 2),
    #stringify(3 * 2),
    #stringify(3 * 5)
]

#stringify라는 이름의 macro는 '계산'만 단일 매개변수로 취급한다.
그리고, 컴파일타임에 위에서 본 tuple형식으로 변환되어 계산과 결과가 일치하도록 보장한다.

 

@freestanding(expression)
macro stringify(_ value: Int) -> (Int, String)

#stringify는 함수와 생김새가 매우 흡사한데, 정수를 매개변수로 하여, 결과와 계산식을 tuple형태로 반환한다.

 

또한 매크로를 사용할 때 아래의 케이스에는 컴파일 에러를 발생시킨다.

1. 매크로 표현식의 인수가 매개변수와 일치하지 않는 경우
2. 매크로 표현식의 인수에 대한 타입 검사를 수행하지 않는 경우

 

#stringify("hello world") // ERROR >> Cannot convert value of type 'String' to expected argument type 'Int'

이처럼 매크로 표현식의 인수와 다른 타입의 값을 매개변수로 작성하면 에러가 발생

 

즉, Compiler는 모든 인수가 macro의 파라미터와 일치하는지 먼저 확인 후, macro를 동작시킨다.

 

그리고 해당 #stringify는 독립형 표현식 매크로(Freestanding Expression macro) 이기 때문에,
표현식을 작성할 수 있는 위치라면 어디서든 일반적인 값처럼 사용할 수 있다. (함수의 return 결과와 같은...)

 

여기서 표현식을 작성할 수 있는 위치 란?
변수 할당, 함수 호출, 연산 등 과 같이 일반적인 값이 위치할 수 있는 곳을 의미한다.

즉, type 앞에 나오는 키워드 (ex. final class A {... }에서의 final) 등은 표현식의 위치가 아니다!

 

✅ 단일 매크로 표현식

 

macro는 확장을 수행하고자, Compiler Plug-in에서 구현을 정의한다.
그리고, Compiler는 macro 표현식의 전체 소스코드를 해당하는 macro Plug-in에 전달한다.

 

macro Plug-in은 macro의 소스 코드를 SwiftSyntax 트리로 파싱 하는데, 이 SwiftSyntax 트리는, macro의 구조적 표현이자 macro 동작의 기반이 된다.

 

#stringify macro는 SwiftSyntax 트리에서 노드의 구조로 표현된다.

• identifier : macro의 이름을 정의
• InfixOperatorExprSyntax : 2 + 3이라는 중위연산자 식

macro는 구현 자체를 Swift로 구현하고, SwiftSyntax트리로 변환이 매우 자유롭다.

 

위 예시의 결과인 tuple을 생성하고, 생성된 SwiftSyntax 트리를 다시 소스 코드로 직렬화해서 Compiler로 보내면, 기존의 #stringify(2+3)라는 macro 표현식이 확장된 코드로 대체된다.

 

---

 

Create a macro

Xcode에서 macro Template를 직접 만들어보자.

 

1️⃣ macro 템플릿 생성하기

 

Xcode >> File >> New >> Package... 를 선택한다.

 

Swift macro를 선택하고, 새롭게 생성해준다.

 

생성된 Swift macro 탬플릿을 확인해 보면, 이전에 우리가 다뤘던 #stringify가 표현식에 사용되는 것을 확인할 수 있다.

 

실제 macro가 확장된 모습을 확인하려면, 표현식을 우클릭해서 Expand macro를 선택하면 된다

 

2️⃣ macro 직접 정의하기

우리가 직접 macro를 정의해 보기 전에, 우선 #stringify가 어떻게 정의되어있는지를 확인해 보자.

 

사진 속 코드와 같이 정수형 대신, 제네릭 타입으로 정의되어 모든 타입 T를 받을 수 있다.
또한 macro는 #externalmacro로 선언된다.

 

즉, 해당 macro를 실제로 수행하려면 WWDCmacro 모듈에서 Stringifymacro타입을 가져오라고 Compiler에게 알리는 것이다.

 

#stringify 매크로는, 독립형 표현식 매크로(Freestanding Expression macro)로 정의되기 때문에 Expressionmacro를 준수해야 한다.

 

위 코드에서 알 수 있듯이, Expressionmacro는 expansion(of node: in context) 함수를 필수요구사항으로 갖는다.

 

expansion(of node: in context)는 Syntax Tree(구문 트리)와 Context를 인자로 취하는데, 이는 컴파일러와의 통신에 필요한 요소들이다.

 

이후에 expansion(of node: in context) 함수는 재작성된 표현식 구문을 return 하게 된다.

 

함수 내부 구현을 살펴보면, 우선 node의 단일 인수(argumentList.first?.expression) 를 macro의 표현식으로 가져온다.

 

#stringify를 선언할 때 단일 매개변수를 취하도록 선언했기 때문에 해당 인수는 반드시 존재하고, 존재하는 모든 인수에 대한 타입 검사를 해야 한다.

 

그리고 문자열 보간법을 활용해서, tuple의 Syntax Tree(구문 트리)를 생성하게 된다.

 

이 함수에서 반환하는 값은 단순한 문자열이 아니라 ExprSyntax 즉, 표현식 구문을 반환하는 것이다.
macro는 이 표현식 구문을 Swift 파서를 이용하여 해석을 진행하고, 실제 표현식으로 변환된다.

 

3️⃣ macro 테스트 코드 작성하기

macro는 런타임에서 expansion 되어 실제 코드로 적용되기 전에는, 버그가 있는지 알아차리기 까다롭다.
따라서 macro가 제대로 동작하는지 테스트하는 과정이 있어야 한다.

 

macro 템플릿에서 제공하는 Unit-Test를 확인해보자.

 

assertmacroExpansion

• SwiftSyntax 패키지의 함수이고, #stringify가 올바르게 expansion 되는지를 검증
• 위의 예시에서는 첫 번째 인자로 #stringify의 표현식을 리터럴로 받고, expandedSource라는 이름의 파라미터에는 expansion 된 결과를 문자열로 입력받는다
• 그리고 macros 인자에는 [String: macro.Type] 타입을 받는데, 이는 expansion으로 사용할 macro를 지정하는 것이다.

실제 해당 테스트코드를 실행시키면, 성공하게 된다.

 

지금까지 정리된 macro의 특징

• macro 선언을 하기 위해서, macro의 signature와 역할을 정의한다.
• 이후 Compiler plug-in이 내부적으로 구문트리로 변환하여 결과에 대한 해석을 하고, 이를 expansion에서 결과 코드로 변환한다.
• 또한, macro는 testable 하다.

 

---

 

macro roles

 

macro는 지금까지 알아보았던 @freestanding(expression)(독립형 표현식 매크로) 이외에도 수많은 형태가 존재한다.

이번 세션에서는 @attached(member)에 대해 주로 알아볼 예정임.

 

@attached(member) macro 소개

@attached(member)를 적용하기 위해 가정한 상황은 아래와 같다.

 

''나는 현재 스키 강사로 일 하고 있고, 학생들과 함께 갈 여행을 계획하는 데 사용할 앱을 개발 중이다.
그리고 스키장에 갔을 때, 학생들의 스키 수준에 따라 너무 어려운 슬로프에 초보자를 데려가지 않도록 하고 싶다."

enum Slope {
    case beginnersParadise
    case practiceRun
    case livingRoom
    case olympicRun
    case blackBeauty
}

enum EasySlope {

    case beginnersParadise
    case practiceRun

    init? (_ slope: Slope) {
        switch slope {
        case .beginnersParadise: self = .beginnersParadise
        case .practiceRun: self = .practiceRun
        default: return nil
        }
    }

    var slope: Slope {
        switch self {
        case .beginnersParadise: return .beginnersParadise
        case .practiceRun: return .practiceRun
        }
    }
}

이렇게 Slope와 EasySlope 열거형을 정의함으로써, 선택된 Slope를 기준으로 EasySlope에 속하는지를 확인할 수 있은 훌륭한 타입 안정성을 제공할 수 있다.

 

하지만, 반복적인 코드가 너무 많고 이를 macro를 활용해서 개선해 보자

 

반복적인 Slope에 대한 macro 작성

목표는, EasySlope의 initializer와 computed-property를 자동으로 생성하는 것이다.

1. initializer와 computed-property는 모두 EasySlope타입의 member이므로, @attatched(member)를 선언해야 한다.
2. macro의 구현을 포함한 Compiler plug-in을 생성한다.
   -> 이때, macro에 대한 테스트를 진행해야 하기 때문에 구현체는 비워둔다(empty implementation)
3. macro에 대한 테스트 코드를 작성한다.
4. 테스트가 성공하면, 테스트 케이스와 일치하도록 실제 구현체를 구현한다.
5. 완성된 macro를 실제 App의 코드에 통합한다.

 

/// Defines a subset of the `Slope` enum
///
/// Generates an initializer that converts a `Slope` to this type if the slope is
///     declared in this subser, otherewise return `nil`
///
/// - Implement: All enum cases declared in this macro must also exist in the
///              `Slope` enum.
@attached(member, names: named(init))
public macro SlopeSubset() = #externalmacro(module: "WWDCMacros", type: "SlopeSubsetMacro")

macro의 이름은 SlopeSubset으로 명명했다
-> EasySlope는 Slope의 부분집합 이기 때문에..!!

 

@attached(member, names: named(init))

또한, 여기서 알 수 있듯이 macro를 구현에서 작성할 멤버의 이름도 정의한다..!

 

public macro SlopeSubset() = #externalmacro(module: "WWDCMacros", type: "SlopeSubsetMacro")

현재는 macro의 signature를 선언한 상태지만, 실제 동작을 수행하는 expansion은 아직 구현하지 않았다.
expansion을 구현하기 위해서, WWDCmacros 모듈의 SlopeSubsetmacro 타입을 참조한다.

 

이제 해당 타입(SlopeSubsetmacro)을 생성해서 실제 macro를 구현해 보자!

 

/// Implementation of the `SlopeSubset` macro.
public struct SlopeSubsetmacro: MemberMacro {

}

@main
struct WWDCPlugin: CompilerPlugin {
    let providingmacros: [Macro.Type] = [
    ]
}

우리는 현재 SlopeSubset을 @attatchd(member)로 선언했기 때문에, 해당 SlopeSubset가 따르는 Type인 SlopeSubsetmacro의 구현체는 Membermacro 프로토콜을 준수해야 한다.

 

public struct SlopeSubsetmacro: MemberMacro {
    public static func expansion(
        of node: AttributeSyntax,
        providingMembersOf declaration: some DeclGroupSyntax,
        in context: some macroExpansionContext
    ) throws -> [DeclSyntax] {
        return []  /// > 실제 구현체를 구현하기 전에, 우선 테스트 코드를 작성하기 위해 빈 배열을 리턴
    }
}

/// > 컴파일러에게, `SlopeSubsetmacro`라는 macro타입이 존재함을 노출함
@main
struct WWDCPlugin: CompilerPlugin {
    let providingmacros: [Macro.Type] = [
        SlopeSubsetmacro.self
    ]
}

Membermacro 프로토콜 또한 Expressionmacro과 마찬가지로, 필수 요구사항으로 expansion 함수를 갖는다.

• node: macro를 Type에 적용할 때 사용하는 실제 attribute를 가져옴
  -> 여기서는 @SlopeSubset (macro의 Signature)
• declaration: macro가 적용될 실제 타입
  -> 여기서는 EasySlope.Self

이제 실제 구현을 하기 전에, macro가 잘 동작하는지 확인하기 위해 테스트 케이스를 작성해보자.

final class WWDCTests: XCTestCase {
    func testSlopeSubset() {
        assertmacroExpansion(
            originalSource: String,
            expandedSource: String,
            macros: [String : any Macro.Type]
        )
    }
}

템플릿의 테스트 케이스처럼 assertmacroExpansion을 통해 macro의 동작을 검증한다.

 

let testmacros: [String: Macro.Type] = [
    "SlopeSubset": SlopeSubsetmacro.self,
]

final class WWDCTests: XCTestCase {
    func testSlopeSubset() {
        assertMacroExpansion(
            """
            @SlopeSubset
            public enum EasySlope {
                case beginnersParadice
                case practiceRun
            }
            """,
            expandedSource:
            """
            public enum EasySlope {
                case beginnersParadice
                case practiceRun
            }
            """,
            macros: testmacros
        )
    }
}

1. originalSource에는 실제로 검증하고자 하는 코드인 아래의 string 리터럴을 적는다.
2. SlopeSubsetmacro에 대한 expansion함수의 구현체가 현재는 빈 배열을 반환하기 때문에, macro에 의해서 변환되는 값은 아무것도 없다는 것을 의미한다. 즉, 원본 코드 그대로 expansion 된다.
3. 마지막으로, 테스트할 macro의 이름인 SlopeSubset과 해당 macro의 구현체인 SlopeSubsetmacro를 매핑한 testmacro를 생성하고 함수에 전달한다.

 

그리고 해당 테스트 코드를 실제로 실행시켜 보면, 성공적으로 통과하게 된다.

이때, 주의할 점은 macro는 개발 중인 플랫폼(예: Mac의 macOS)에서만 지원되므로, 실제 테스트가 작동하려면 빌드 대상을 시뮬레이터가 아닌 Mac으로 지정해야 한다!!!

 

이번엔 우리가 실제로 생성하길 원하는 initializer 코드를 expandedSources에 넣고 테스트를 돌려보자

 

당연하게도, 아직 macro의 실제 구현부에서는 아무런 작업이 없기 때문에 테스트는 실패하게 된다.

그럼 이제, 실제 구현부를 작성해 보자

 

1. declaration을 가져오고자 하는 type으로 캐스팅하기

public static func expansion(
    of node: AttributeSyntax,
    providingMembersOf declaration: some DeclGroupSyntax,
    in context: some MacroExpansionContext
) throws -> [DeclSyntax] {
    guard let enumDecl = declaration.as(EnumDeclSyntax.self) else { 
        //TODO: Emit an error here
        return [] 
    }
    return []
}

구현하고자 하는 initializer는 EasySlopes의 열거형에 선언된 모든 요소를 새롭게 전환한다.
이를 위해 declaration에서 모든 case를 회수해와야 하므로 declaration을 enum으로 캐스팅한다.

 

그리고, enum이 아닌 타입이 macro로 넘어오면 error를 방출해야 하므로 일단 TODO로 둔다.

 

2. 캐스팅한 enum으로부터 모든 요소를 가져오기

이제 캐스팅한 enum에서 모든 요소(case)들을 가져와야 하는데, Syntax Tree(구문 트리)를 분석하여 필요한 값을 가져와야 한다.

Syntax Tree(구문 트리)를 분석하기 위해서 디버깅 단계에서 braking-point를 지정하여 print-object(po)를 활용하면 실제 Syntax Tree(구문 트리)의 구조를 확인하고 필요한 값을 확인할 수 있다.

 

출력된 Syntax Tree(구문 트리)에서 가장 안 쪽에 있는 노드는, 우리가 필요한 EnumCaseDeclSyntax 인 beginnersParadice, practiceRun을 표현하고 있다.

 

이 2가지 요소를 가져오기 위해선, Syntax Tree(구문 트리)의 구조를 단계별로 타고 가서 접근해야 한다.

 

2-1. Syntax Tree(구문 트리)를 분석하고 필요한 데이터에 접근하기

가장 바깥의 EnumDeclSyntax에 있는 memberBlock은 중괄호(Brace)와 실제 멤버(members)를 포함한다.
내부 member들에 접근하기 위해선, enumDecl.memberBlock.members로 시작해야 할 것이다.

 

members 내부에 index로 구분된 member는, 선언부(decl)와 optional로 세미콜론(여기선 없음)을 포함한다.
우리는 이 중에서 case를 실제로 선언하는 부분인 EnumCaseElememtListSyntax가 필요하다.

따라서, compactMap을 활용해서 EnumCaseDeclSyntax타입으로 캐스팅 되는 모든 값을 가져온다.
-> EnumCaseDeclSyntax가 아닌 타입은 모두 제거하기 위해 compactMap활용

 

이렇게 가져온 let caseDecls는 각 각 단일 요소일 수도 있지만, 한 줄에 여러 요소를 한 번에 정의할 수도 있다
-> case beginnersParadice, practiceRun 이런 식으로..!!

 

이런 경우를 대응하기 위해서 각 요소별로 flatMap을 통해 모든 elements를 가져와야 한다.

 

필요로 했던 모든 case를 회수 한 상태..!!

 

3. 실제 initializer 구축하기

모든 열거형 요소를 회수했으므로, 실제 initializer를 구축해 보자.

 

initializer의 선언부에는 switch 표현식이 존재한다.
해당 표현식에는, 각 요소에 대한 동작 케이스와 nil을 반환하는 default를 갖고, 우리는 이 모든 케이스에 대한 Syntax Node(구문 노드)를 작성해야 한다.

 

그리고 이런 Syntax Node(구문 노드)를 작성하기 위해선 아래의 2가지 방법이 있다.

1. po를 활용한 Syntax Tree(구문 트리) 출력해서 찾는 방법
2. SwiftSyntax 문서를 직접 읽고 명령어 찾는 방법

 

3-1. initializerDeclSyntax 구축하기

우선, initializerDeclSyntax를 만들어보도록 하자.

 

initializerDeclSyntax는 @resultBuilder를 활용해서 본문을 빌드하고, header를 지정할 수 있다.
header는 init 키워드와 모든 매개변수를 지정하고, 이것을 @resultBuilder에서 for 루프를 사용하여 필요한 요소마다 전부 반복할 수 있다.

 

본문 내부에는 switch 표현식이 필요하다.
마찬가지로 switch 표현식을 위한 구문인 SwitchExprSyntax 도 InitializerDeclSyntax와 마찬가지로 header와 @resultBuilder에서 사용할 본문 코드블록이 필요하다.

 

그리고 switch의 @resultBuilder블록에는 앞에서 모았던 elements들을 활용할 수 있다.
이때, 동일 구문에 대한 반복이 있으니 for문을 활용하면 된다

 

또한, case에 대한 표현식인 SwitchCaseSyntax를 활용하고 각 요소에 대해서 문자열 보간을 사용하여 항목을 생성해 준다.

 

반복적인 case 이후에는 default에 해당하는 요소도 따로 for문 밖에 작성해 주자.

 

그리고 마지막으로 initializer를 DeclSyntax로 변환하여 return 해준다.

 

(여기서, 비하인드 스토리는  expandedSource 를 작성할 때 미세한 공백과 줄 바꿈 때문에 몇 번 실패했다는 사실,,,, 줄 바꿈과 공백은 꼭 신경쓰자....)

아름답게 성공한다...!

 

4. 실제 사용을 위해 App에 macro Package 추가하기

이제 실제 App인 SampleApp_Ski에 우리가 만든 macro를 추가해 보자.

 

File >> Add Package Dependencies를 선택

 

하단의 Add Local... 선택 후, 생성한 WWDC를 추가해 준다.

 

이제 실제 WWDC 모듈을 가져와서, SlopeSubset macro를 EasySlope 타입에 적용할 수 있다.

 

하지만 지금 상태에서 빌드를 하면, 위와 같은 에러가 발생하는데
당연히 macro에 의해서 생성되는 init?()과 중복되기 때문에, 우리가 직접 정의했던 init?() 지워버려야 한다.

 

그리고 @SlopeSubset을 우클릭해서 expand macro를 선택하면, 컴파일러를 통해 확장된 코드를 볼 수 있다.
computed-property인 var slope: Slope {... } 도 마찬가지로 macro로 정의할 수 있다.

 

Write macro 정리

1. Swift macro package를 생성해서 template을 만든다.
2. 실제 expand 될 코드를 Syntax Tree(구문 트리)로 작성하기 위해, break-point를 직접 걸어서 확인함
   -> 이를 통해, 추출할 element까지 접근하는 Syntax 구조를 알 수 있음
3. 테스트 케이스를 통해, macro 결과를 정해두고 실제 expansion함수 구현체를 개발한다.
4. 구현이 완료된 macro를 Package의 형태로 App에 추가한다.

 

---

 

Diagnostics

macro가 지원하지 않는 기능에 macro를 사용하게 된다면 어떻게 될까?
이럴 땐, 사용자가 잘못 확장된 코드를 통해 디버그 하도록 하는 대신 항상 오류 메시지를 내보내게 된다.

 

그런 의미에서 위의 코드에 남겨둔 TODO를 처리하도록 하자.
이 경우는, @SlopeSubset이 선언된 타입이 enum이 아닌 경우에 error를 반환하게 되는 케이스이다.

 

final class WWDCTests: XCTestCase {

    func testSlopeSubsetOnStruct() {
        assertMacroExpansion(
            """
            @SlopeSubset
            struct Skier {
            }
            """,
            expandedSource:
            """
            struct Skier {
            }
            """,
            macros: testMacros
        )
    }
}

이전에 구현할 때와 마찬가지로, 우선 테스트케이스 먼저 정의하는데
우리는 error를 발생시키는 케이스를 테스트해야 하기 때문에, struct에 @SlopeSubset을 적용해 보자

 

final class WWDCTests: XCTestCase {
    func testSlopeSubsetOnStruct() throws {
        assertMacroExpansion(
            """
            @SlopeSubset
            struct Skier {
            }
            """,
            expandedSource:
            """
            struct Skier {
            }
            """,
            diagnostics: [
                DiagnosticSpec(message: "@SlopeSubset can only be applied to an enum", line: 1, column: 1)
            ],
            macros: testMacros
        )
    }
}

이렇게 되면 열거형 요소가 없기 때문에, 실제 macro에서는 initializer를 생성하지 않고 Diagnostics(진단)을 내보내야 한다.
-> 여기서 Diagnostics(진단) 이란, 'SlopeSubset은 열거형에만 적용될 수 있습니다'라고 메시지를 남기는 것!

 

```swift
final class WWDCTests: XCTestCase {
    func testSlopeSubsetOnStruct() throws {
        assertMacroExpansion( // ERROR: failed - Expected 1 diagnostics but received 0:
            """
            @SlopeSubset
            struct Skier {
            }
            """,
            expandedSource:
            """
            struct Skier {
            }
            """,
            diagnostics: [
                DiagnosticSpec(message: "@SlopeSubset can only be applied to an enum", line: 1, column: 1)
            ],
            macros: testMacros
        )
    }
}

이 상태에서 테스트를 진행하면 실패하게 되고, 아직 진단 메시지는 출력되지 않는다.

 

macro error 출력하기

macro에 대한 error는 Swift Error 프로토콜을 준수하는 모든 타입으로 표현 가능하다.

enum SlopeSubsetError: CustomStringConvertible, Error {
    case onlyApplicableToEnum
    var description: String {
        switch self {
        case .onlyApplicableToEnum: return "@SlopeSubset can only be applied to an enum"
        }
    }
}

/// Implementation of the `SlopeSubset` macro.
public struct SlopeSubsetMacro: MemberMacro {
    public static func expansion(
        of node: AttributeSyntax,
        providingMembersOf declaration: some DeclGroupSyntax,
        in context: some MacroExpansionContext
    ) throws -> [DeclSyntax] {
        guard let enumDecl = declaration.as(EnumDeclSyntax.self) else {
            throw SlopeSubsetError.onlyApplicableToEnum
        }
        ...
    }
}

이렇게 expansion내부에서 error를 throw 하면, 실제 macro를 적용하는 attribute에서 표시된다.

 

+ 추가적으로 좀 더 많은 케이스에 대한 error 대응을 하려면, addDiagnostic 메서드를 활용하면 된다.

 

그리고 실제로 @SlopeSubset를 구조체에 적용하면 위와 같이 error 메시지가 잘 나오는 것을 확인할 수 있다.

 

완성된 macro의 제네릭 타입 추가 -> macro의 일반화

해당 macro가 Slope라는 고정적인 열거형 타입뿐 아니라, 일반적인 열거형 타입에도 적용되면 많은 개발자들이 효과적으로 사용할 수 있을 것이다.

 

이를 위해선, 제네릭 매개변수를 macro의 선언에 추가해 주면 된다.
그리고, SlopeSubset이라는 이름도 EnumSubset으로 변경하도록 하자

 

    func testSlopeSubset() {
        assertMacroExpansion(
            """
            @EnumSlope<Slope>
            enum EasySlope {
                case beginnersParadice
                case practiceRun
            }
            """,
            ...
        )
    // > **(lldb) po node**
    // >AttributeSyntax
    // >├─atSign: atSign
    // >╰─attributeName: IdentifierTypeSyntax
    // >├─name: identifier("EnumSlope")
    // >╰─genericArgumentClause: GenericArgumentClauseSyntax
    // >    ├─leftAngle: leftAngle
    // >    ├─arguments: GenericArgumentListSyntax
    // >    │ ╰─[0]: GenericArgumentSyntax
    // >    │   ╰─argument: IdentifierTypeSyntax
    // >    │     ╰─name: identifier("Slope")
    // >    ╰─rightAngle: rightAngle

또한, macro의 구현체에서 현재는 Slope라는 고정 타입 대신에 제네릭 매개변수를 회수해야 한다.
이전과 마찬가지로 break-point를 활용해서 node에 대한 Syntax Tree(구문 트리)를 출력하여 분석한다.

 

        guard let superSetType = node
            .attributeName.as(IdentifierTypeSyntax.self)?
            .genericArgumentClause?
            .arguments.first?
            .argument else {
            // TODO: Handle error
            return []
        }


        // > (11db) po superSetType
        // > IdentifierTypeSyntax
        // > ╰─name: identifier("Slope")

이를 실제 코드로 추출하면 위와 같다.

 

guard let superSetType = node
    .attributeName.as(IdentifierTypeSyntax.self)?
    .genericArgumentClause?
    .arguments.first?
    .argument else {
    // TODO: Handle error
    return []
}

...

let initializer = try InitializerDeclSyntax("init?(_ slope: \(superSetType))") { ... }

그럼 기존의 let initializer를 위의 코드처럼 수정할 수 있다.

이후 테스트를 진행하면, 모두 잘 통과한다!

 

---

 

Summary

• macro Package Template를 통해 손쉽게 시작할 수 있다.
• 매크로를 개발하는 동안 테스트 케이스를 꼭 작성해서 매크로가 생성하는 코드가 유효한지 확인해야 한다.
• 진행하면서 expansion 함수에 중단점을 설정하고 디버거에서 Syntax Tree(구문 트리)를 출력해 Syntax Tree(구문 트리)를 분석할 수 있다.
• 특정 상황에서 매크로를 적용할 수 없다면 커스텀 오류 메시지를 항상 내보내야 합니다

 

---

참고자료:

https://medium.com/@gar.hovsepyan/macros-in-swift-a-practical-guide-to-using-fa1a24eba8bb

Macros in Swift: A Practical Guide to Using

https://developer.apple.com/videos/play/wwdc2023/10166/

Write Swift macros - WWDC23 - Videos - Apple Developer