在 Swift 宏体系中，BodyMacro 是一种专门用于替换方法体实现的宏协议。通过 BodyMacro，开发者可以为已有方法、构造器等提供新的实现代码，减少重复代码的书写，并将功能逻辑更加灵活地

Swift 宏系统中，MemberAttributeMacro 是一种用于为类型中的成员声明自动附加属性标记的宏。它适用于需要为多个成员统一附加如 @available、@objc、@discarda

在 Swift 宏系统中，ExtensionMacro 是一种用于自动生成扩展（extension）代码块的宏协议，适用于为类型生成协议实现、工具方法、便捷功能等 “类型之外”的附加内容。它是 Swi

在 Swift 宏体系中，AccessorMacro 是一种专用于自动生成属性访问器（如 getter、setter、willSet、didSet 等） 的宏协议。它适用于那些希望对属性访问行为进行自

在 Swift 宏体系中，PeerMacro 是一种非常灵活且强大的宏协议，专用于生成与绑定声明处于同一作用域的“对等”声明，常用于自动扩展同级的变量、函数或类型定义。

本节将深入介绍 PeerMacro 的用途、定义、参数结构以及实际示例，帮助你理解它在元编程场景中的独特价值。

建议结合《Swift Macros - 宏之全貌》和《Swift Macros - 宏之协议》一并阅读，便于全面理解宏系统的角色协作模型。

1. PeerMacro 的定义

标准库中 PeerMacro 的定义如下：

 public protocol PeerMacro: AttachedMacro {
  static func expansion(
    of node: AttributeSyntax,
    attachedTo declaration: some DeclSyntaxProtocol,
    in context: some MacroExpansionContext
  ) throws -> [DeclSyntax]
 }

这意味着：

• 它是一个 附加宏（attached macro） ；
• 不能生成成员，而是生成与附着声明同级的其他声明；
• 它的返回值为 [DeclSyntax]，即可以注入多个顶层/局部声明；
• 使用范围包括变量、函数、类型、扩展等几乎所有可声明位置。

---

2. PeerMacro 的典型用途

Peer 宏的应用场景非常广泛，常用于：

场景	示例	说明
自动生成伴生变量	@WithWrapper	为属性生成 _xxx 存储变量
自动生成伴生函数	@BindAction	为属性自动生成相关行为函数
生成衍生声明	@AutoObservable	为属性自动生成观察者包装及通知机制
声明反射信息	@Reflectable	自动生成结构体元信息注册代码

特别适合那些需要基于现有声明生成“相关声明”的情境，但不适合直接插入原声明体内的场合。

---

3. 参数详解

of node: AttributeSyntax

代表宏的语法标记本身，例如 @WithWrapper。可用于：

• 宏参数提取；
• 判断具体调用语法。

---

attachedTo declaration: some DeclSyntaxProtocol

• 表示宏附着的原始声明节点；
• 类型是 DeclSyntaxProtocol，表示可以是变量、函数、类型等；
• 你可以从中提取关键元信息（如变量名、类型名、访问级别等）。

---

in context: some MacroExpansionContext

上下文对象，常用于：

• 生成唯一名称（防止冲突）；
• 获取源文件路径、位置；
• 报告诊断信息（如参数错误）。

---

4. 对等声明的展开位置

Peer 宏生成的声明会插入到与原声明相同的作用域中，而不是类型或函数内部。

例如：

 @WithWrapper
 var name: String

展开后等同于：

 var name: String
 private var _name: String = ""

即：_name 是 name 的“对等声明”，它们在同一语法级别上。

---

5. 示例解析

示例：为变量自动生成属性

用法

 struct User {
    @DebugEqual
    var userName: String = ""
 }
 
 // 展开后
 struct User {
    var userName: String = ""
     
    var debug_userName: String {
        "userName = (userName)"
    }
 }

实现

 @attached(peer, names: arbitrary)
 public macro DebugEqual() = #externalMacro(module: "McccMacros", type: "DebugEqualMacro")
 
 public struct DebugEqualMacro: PeerMacro {
    public static func expansion(
        of node: AttributeSyntax,
        providingPeersOf declaration: some DeclSyntaxProtocol,
        in context: some MacroExpansionContext
    ) throws -> [DeclSyntax] {
        // 把通用声明转成变量声明
        guard let varDecl = declaration.as(VariableDeclSyntax.self),
              // 变量可鞥有多个绑定（var a = 1, b = 2）,这里获取第一个。
              let binding = varDecl.bindings.first,
              // 获取变量名，比如”userName“
              let identifier = binding.pattern.as(IdentifierPatternSyntax.self)?.identifier.text
        else {
            return []
        }
 
 
        // 生成新的变量名，如 debug_username
        // raw: 的作用？原样插入这个标识符文本，不会加引号，也不会逃逸。这是写 Swift 宏时推荐的写法之一。
        return [
            """
            var debug_(raw: identifier): String {
                "(raw: identifier) = \((raw: identifier))"
            }
            """
        ]
    }
 }

6. 注意事项

• PeerMacro 会生成多个完整的顶层声明节点，开发者需手动控制命名与作用域；
• 若生成的名称不一致，建议配合 names: 标注宏声明；
• 生成类型或函数声明时，需手动处理访问修饰符和重名冲突。

7. 总结

PeerMacro 是 Swift 宏系统中“横向扩展”的核心工具，它允许开发者在不修改原始声明的前提下添加紧密关联的辅助声明。适用于：

• 分离逻辑与存储
• 为现有属性扩展行为能力
• 构建声明式属性模型

当你需要构建“围绕声明的附属结构”，PeerMacro 就是你的利器。

在 Swift 中，结构体和类的声明体（即 {} 中的内容）常常会包含许多重复或模式化的成员声明。为了提升开发效率并避免重复劳动，Swift 宏系统提供了一种用于自动生成成员声明的宏协议：MemberMacro。在 Swift 宏体系中，MemberMacro 是一种具有极高实用价值的宏协议，它专门用于在类型声明内部生成新的成员（如属性、方法、构造器等）。这种宏是典型的附加宏（attached macro） ，能够大幅减少重复成员定义的样板代码，提高类型声明的表达能力。

本节建议结合《Swift Macros - 宏之全貌》和《Swift Macros - 宏之协议》一并阅读，以便更好地理解宏在声明结构中的角色。

1. MemberMacro 的定义

MemberMacro 是一种 附加宏协议，用于将成员注入至类型声明体中。它只作用于结构体、类、actor、枚举这些具备声明体的类型定义，不能用于函数、变量或其他非类型声明。

它在 Swift 中的声明为：

 public protocol MemberMacro: AttachedMacro {
  static func expansion(
    of node: AttributeSyntax,
    providingMembersOf declaration: some DeclGroupSyntax,
    in context: some MacroExpansionContext
  ) throws -> [DeclSyntax]
 }

参数名	类型	说明
node	AttributeSyntax	当前宏调用的语法节点（包含宏名与参数）
declaration	some DeclGroupSyntax	宏所附加的类型声明体，例如 struct 或 class
context	some MacroExpansionContext	提供诊断、源文件信息等上下文能力

你可以通过 MacroExpansionContext 提供的 diagnose() 方法抛出编译错误，也可以用 context.location(of:) 进行精确定位。

返回值为 [DeclSyntax]，表示你希望宏注入的成员声明数组。例如你可以生成变量、函数、嵌套类型等内容：

 return [  "var id: String = UUID().uuidString",  "func reset() { self.id = UUID().uuidString }" ]
 .map { DeclSyntax(stringLiteral: $0) }

💡 注意：返回的成员会插入到原始类型声明体中，因此要避免命名冲突。

📌 使用限制

• 只可用于具有声明体（{}）的类型定义：struct、class、enum、actor
• 不可用于 func、var、extension 等其他声明
• 若注入的成员包含具名声明（如 var id），必须在宏声明中通过 names: 显式声明，以避免命名未覆盖错误（Declaration name 'id' is not covered by macro）

2. 使用场景分析

MemberMacro 适用于所有需要自动生成类型成员的场景，特别是：

场景	示例	说明
自动生成协议实现	@AutoEquatable	自动实现 Equatable 的 == 方法
自动添加辅助属性	@Observe	为属性生成 _xxx 存储与监控 getter
自动实现构造器	@AutoInit	基于属性自动生成初始化函数
自动生成默认值	@WithDefaults	为成员属性自动附加默认实现

3. 示例解析

示例1：AddID

用法：

 @AddID
 struct User {
  var name: String
 }
 
 // 等价于
 struct User {
  var name: String
  var id = UUID().uuidString
 }

实现：

 @attached(member, names: named(id))
 public macro AddID() = #externalMacro(
  module: "MyMacroImpl",
  type: "AddIDMacro"
 )
 
 public struct AddIDMacro: MemberMacro {
  public static func expansion(
    of node: AttributeSyntax,
    providingMembersOf declaration: some DeclGroupSyntax,
    in context: some MacroExpansionContext
  ) throws -> [DeclSyntax] {
    return [
      "var id = UUID().uuidString"
    ].map { DeclSyntax(stringLiteral: $0) }
  }
 }

如果不明确名称

 @attached(member)

运行会报错：

 ❗️Declaration name 'id' is not covered by macro 'AddID'

说明你使用的是 @attached(member) 宏，但没有在宏声明中说明要生成的成员名字，Swift 宏系统默认是不允许你偷偷“注入”成员名的，除非你通过 names: 明确标注。

示例2：CodableSubclass

对于继承自某个父类的子类，我们希望自动生成 CodingKeys 与 init(from:) 方法.

用法

 class BaseModel: Codable {
    var name: String = ""
 }
 
 @CodableSubclass
 class StudentModel: BaseModel {
    var age: Int = 0
 }
 
 
 // 宏展开后等效于
 class StudentModel: BaseModel {
    var age: Int = 0
     
    private enum CodingKeys: String, CodingKey {
        case age
    }
 
    required init(from decoder: Decoder) throws {
        try super.init(from: decoder)
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.age = try container.decode(Int.self, forKey: .age)
    }
 }

实现

 @attached(member, names: named(init(from:)), named(CodingKeys))
 public macro CodableSubclass() = #externalMacro(module: "McccMacros", type: "CodableSubclassMacro")
 
 
 public struct CodableSubclassMacro: MemberMacro {
    public static func expansion(
        of node: AttributeSyntax,
        providingMembersOf declaration: some DeclGroupSyntax,
        in context: some MacroExpansionContext
    ) throws -> [DeclSyntax] {
        // 1. 验证是否是类声明
        guard let classDecl = declaration.as(ClassDeclSyntax.self) else {
            throw MacroError.message("@CodableSubclass 只能用于类")
        }
         
        // 2. 验证是否有父类
        guard let inheritanceClause = classDecl.inheritanceClause,
              inheritanceClause.inheritedTypes.contains(where: { type in
                  type.type.trimmedDescription == "BaseModel" ||
                  type.type.trimmedDescription.contains("Codable")
              }) else {
            throw MacroError.message("@CodableSubclass 需要继承自 Codable 父类")
        }
         
        // 3. 收集所有存储属性
        let storedProperties = classDecl.memberBlock.members
            .compactMap { $0.decl.as(VariableDeclSyntax.self) }
            .filter { $0.bindingSpecifier.text == "var" }
            .flatMap { $0.bindings }
            .compactMap { binding -> String? in
                guard let pattern = binding.pattern.as(IdentifierPatternSyntax.self) else {
                    return nil
                }
                return pattern.identifier.text
            }
         
        // 4. 生成 CodingKeys 枚举
        let codingKeysEnum = try EnumDeclSyntax("private enum CodingKeys: String, CodingKey") {
            for property in storedProperties {
                "case (raw: property)"
            }
        }
         
        // 5. 生成 init(from:) 方法
        let initializer = try InitializerDeclSyntax("required init(from decoder: Decoder) throws") {
            // 调用父类解码器
            "try super.init(from: decoder)"
             
            // 创建容器
            "let container = try decoder.container(keyedBy: CodingKeys.self)"
             
            // 解码每个属性
            for property in storedProperties {
                "self.(raw: property) = try container.decode((raw: getTypeName(for: property, in: declaration)).self, forKey: .(raw: property))"
            }
        }
         
        return [DeclSyntax(codingKeysEnum), DeclSyntax(initializer)]
    }
     
    private static func getTypeName(for property: String, in declaration: some DeclGroupSyntax) -> String {
        for member in declaration.memberBlock.members {
            guard let varDecl = member.decl.as(VariableDeclSyntax.self) else { continue }
             
            for binding in varDecl.bindings {
                guard let identifierPattern = binding.pattern.as(IdentifierPatternSyntax.self),
                      identifierPattern.identifier.text == property else {
                    continue
                }
                 
                if let typeAnnotation = binding.typeAnnotation {
                    return typeAnnotation.type.trimmedDescription
                }
            }
        }
         
        // 默认返回 Any，如果找不到匹配
        return "Any"
    }
 }
 
 public enum MacroError: Error, CustomStringConvertible {
    case message(String)
     
    public var description: String {
        switch self {
        case .message(let text):
            return text
        }
    }
 }

4. 总结

MemberMacro 是 Swift 宏体系中连接语法结构与声明注入的关键机制。它让开发者能够根据类型结构自动生成成员，真正实现：

• 结构自动扩展；
• 代码样板消除；
• 类型驱动式逻辑推导。

未来你可以将它与 AccessorMacro、PeerMacro 等组合使用，构建更高层次的声明式元编程能力。

在 Swift 宏体系中，DeclarationMacro 是一种用途广泛的角色，专门用于生成声明级别的代码，如变量、函数、结构体等。它同样属于自由悬挂宏（freestanding macro）的一种

在 Swift 宏体系中，ExpressionMacro 是一种非常重要且常用的角色。它专门用于生成表达式级别的代码，并且属于独立宏（freestanding macro） 的一种。 本节将深入讲解

Swift 宏的强大源于其背后一套精巧严谨的协议体系。这些协议定义了： 宏的行为规范：如何与编译器通信，如何生成语法树 宏的能力边界：什么宏可以插入什么样的结构 宏的输入输出约束：需要接受什么样的输入

版本：2025.04.27｜维护者：Mccc｜欢迎共同维护与补充！

在编写 Swift 宏时，你将频繁与 SwiftSyntax 打交道。SwiftSyntax 将源码拆解为结构化的语法节点（Syntax）树，这些节点覆盖了表达式、声明、语句、类型、模式、属性等各个层面。

本篇文章提供一个实用速查表，帮助你快速了解各类常见语法节点的用途与构造方法，便于高效构建宏所需的代码结构。

目录

• 1. 表达式（ExprSyntax）
• 2. 声明（DeclSyntax）
• 3. 语句（StmtSyntax）
• 4. 类型（TypeSyntax）
• 5. 模式（PatternSyntax）
• 6. 属性（AttributeSyntax）
• 7. 宏（MacroExpansionSyntax）
• 8. 其他常用节点

1. 表达式（ExprSyntax）

用于表示各种计算表达式、函数调用、字面量等，是最常见的语法结构之一。

名称	描述	快速构造示例
ArrayExprSyntax	数组表达式 [a, b, c]	ArrayExprSyntax(elements: [...])
BooleanLiteralExprSyntax	布尔字面量 true / false	BooleanLiteralExprSyntax(value: true)
IntegerLiteralExprSyntax	整数字面量 123	IntegerLiteralExprSyntax(literal: "123")
FloatLiteralExprSyntax	浮点字面量 1.23	FloatLiteralExprSyntax(floatingDigits: "1.23")
StringLiteralExprSyntax	字符串 "abc"	StringLiteralExprSyntax(content: "abc")
IdentifierExprSyntax	标识符 foo	IdentifierExprSyntax(identifier: .identifier("foo"))
FunctionCallExprSyntax	函数调用 foo(a, b)	FunctionCallExprSyntax(calledExpression: ..., arguments: [...])
MemberAccessExprSyntax	成员访问 a.b	MemberAccessExprSyntax(base: ..., name: .identifier("b"))
PrefixOperatorExprSyntax	前缀操作 -a	PrefixOperatorExprSyntax(operator: "-", expression: ...)
PostfixOperatorExprSyntax	后缀操作 a!	PostfixOperatorExprSyntax(expression: ...)
NilLiteralExprSyntax	空值 nil	NilLiteralExprSyntax()
ClosureExprSyntax	闭包 { a in a + 1 }	ClosureExprSyntax(parameters: ..., statements: [...])
TupleExprSyntax	元组 (a, b)	TupleExprSyntax(elements: [...])
TryExprSyntax	try 表达式	TryExprSyntax(expression: ...)
AwaitExprSyntax	await 表达式	AwaitExprSyntax(expression: ...)
AsExprSyntax	类型转换 as	AsExprSyntax(expression: ..., type: ...)
IsExprSyntax	类型检查 is	IsExprSyntax(expression: ..., type: ...)
TernaryExprSyntax	三目表达式 a ? b : c	TernaryExprSyntax(condition: ..., thenExpr: ..., elseExpr: ...)
SequenceExprSyntax	表达式序列 1 + 2 * 3	SequenceExprSyntax(elements: [...])

💡 技巧： 中缀表达式（如 +, -, *）统一由 SequenceExprSyntax 表示，不再有 BinaryExpr。

2. 声明（DeclSyntax）

表示变量、函数、类型、协议等的定义，是构建宏时生成结构代码的核心组成。

名称	描述	快速构造示例
VariableDeclSyntax	变量 let/var	VariableDeclSyntax(bindingSpecifier: "let", bindings: [...])
FunctionDeclSyntax	函数	FunctionDeclSyntax(name: "foo", signature: ..., body: ...)
StructDeclSyntax	结构体	StructDeclSyntax(identifier: "Foo", memberBlock: ...)
ClassDeclSyntax	类	ClassDeclSyntax(identifier: "Foo", memberBlock: ...)
EnumDeclSyntax	枚举	EnumDeclSyntax(identifier: "Foo", memberBlock: ...)
ExtensionDeclSyntax	扩展	ExtensionDeclSyntax(extendedType: ..., memberBlock: ...)
ProtocolDeclSyntax	协议	ProtocolDeclSyntax(identifier: "Foo", memberBlock: ...)
ImportDeclSyntax	导入模块	ImportDeclSyntax(path: ["Foundation"])
TypeAliasDeclSyntax	类型别名	TypeAliasDeclSyntax(identifier: "Alias", type: ...)
AssociatedTypeDeclSyntax	协议中关联类型	AssociatedTypeDeclSyntax(identifier: "T")
MacroDeclSyntax	宏声明	MacroDeclSyntax(identifier: "MyMacro")
OperatorDeclSyntax	自定义操作符声明	OperatorDeclSyntax(operatorKeyword: "operator", name: "+")

3. 语句（StmtSyntax）

用于构建控制流程语句（if、guard、switch 等）和函数体内逻辑结构。

名称	描述	快速构造示例
IfStmtSyntax	if 语句	IfStmtSyntax(conditions: [...], body: ...)
GuardStmtSyntax	guard 语句	GuardStmtSyntax(conditions: [...], body: ...)
WhileStmtSyntax	while 循环	WhileStmtSyntax(conditions: [...], body: ...)
RepeatWhileStmtSyntax	repeat-while 循环	RepeatWhileStmtSyntax(body: ..., condition: ...)
ForStmtSyntax	for-in 循环	ForStmtSyntax(pattern: ..., inExpr: ..., body: ...)
SwitchStmtSyntax	switch 分支	SwitchStmtSyntax(expression: ..., cases: [...])
ReturnStmtSyntax	return 返回	ReturnStmtSyntax(expression: ...)
ThrowStmtSyntax	抛出异常	ThrowStmtSyntax(expression: ...)
BreakStmtSyntax	break 跳出	BreakStmtSyntax()
ContinueStmtSyntax	continue 继续	ContinueStmtSyntax()
DeferStmtSyntax	defer 延后执行	DeferStmtSyntax(body: ...)

4. 类型（TypeSyntax）

用于表示类型声明，包括简单类型、数组、可选、元组、函数类型等。

名称	描述	快速构造示例
SimpleTypeIdentifierSyntax	基本类型 Int, String	SimpleTypeIdentifierSyntax(name: "Int")
OptionalTypeSyntax	可选类型 Int?	OptionalTypeSyntax(wrappedType: ...)
ArrayTypeSyntax	数组类型 [Int]	ArrayTypeSyntax(elementType: ...)
DictionaryTypeSyntax	字典类型 [K: V]	DictionaryTypeSyntax(keyType: ..., valueType: ...)
TupleTypeSyntax	元组类型 (Int, String)	TupleTypeSyntax(elements: [...])
FunctionTypeSyntax	函数类型 (Int) -> Bool	FunctionTypeSyntax(parameters: [...], returnType: ...)
AttributedTypeSyntax	带属性类型 @Sendable	AttributedTypeSyntax(attributes: [...], baseType: ...)
SomeTypeSyntax	some 类型	SomeTypeSyntax(baseType: ...)
MetatypeTypeSyntax	.Type .Protocol	MetatypeTypeSyntax(baseType: ..., typeOrProtocol: ...)
ExistentialTypeSyntax	any 协议类型	ExistentialTypeSyntax(type: ...)

5. 模式（PatternSyntax）

用于 let/var 绑定、模式匹配等结构。

名称	描述	快速构造示例
IdentifierPatternSyntax	标识符模式	IdentifierPatternSyntax(identifier: .identifier("name"))
TuplePatternSyntax	元组模式	TuplePatternSyntax(elements: [...])
WildcardPatternSyntax	通配符 _	WildcardPatternSyntax()
ValueBindingPatternSyntax	let/var 模式	ValueBindingPatternSyntax(bindingSpecifier: "let", pattern: ...)
ExpressionPatternSyntax	表达式匹配	ExpressionPatternSyntax(expression: ...)

6. 属性（AttributeSyntax）

用于修饰声明，包括标准属性和自定义属性包装器。

名称	描述	快速构造示例
AttributeSyntax	标准属性	AttributeSyntax(attributeName: "available")
CustomAttributeSyntax	自定义属性	CustomAttributeSyntax(attributeName: "MyWrapper")

7. 宏（MacroExpansionSyntax）

专门用于表示宏的使用与展开。

名称	描述	快速构造示例
FreestandingMacroExpansionSyntax	表达式独立宏 #stringify(x)	FreestandingMacroExpansionSyntax(macroName: "stringify", arguments: [...])
AttributeMacroExpansionSyntax	属性宏 @MyMacro	AttributeMacroExpansionSyntax(macroName: "MyMacro", arguments: [...])
AccessorMacroExpansionSyntax	Accessor 宏（getter/setter）	AccessorMacroExpansionSyntax(macroName: "MyAccessor")

8. 其他常用节点

名称	描述	快速构造示例
CodeBlockSyntax	一组语句块 { ... }	CodeBlockSyntax(statements: [...])
MemberDeclListSyntax	成员声明列表	MemberDeclListSyntax(members: [...])
ParameterClauseSyntax	参数签名 (x: Int)	ParameterClauseSyntax(parameters: [...])
TupleExprElementListSyntax	元组表达式元素列表	TupleExprElementListSyntax(elements: [...])
TokenSyntax	基础 Token，如标识符/关键字等	.identifier("foo"), .keyword(.func)
SourceFileSyntax	整个 Swift 源文件语法结构	SourceFileSyntax(statements: [...])

来源

为了确保内容的准确性和时效性，欢迎您定期参考官方文档和资源：

swift-syntax源码

SwiftSyntax文档

如有更新，提交MR，一起维护它。

在正式深入宏的世界之前，我们必须理解一个核心概念：Syntax（语法节点） 。它不仅是 Swift 宏生成和操作代码的“原材料”，更是编译器理解代码结构的基础。 语法树(Syntax Tree) 是代

在 Swift 宏系统中，宏类型（Macro Kind） 、宏角色（Macro Role） 与命名说明符（Name Specifier） 共同决定了宏的使用范围和生成内容的可控性。 宏类型 决定宏的附

1. 宏的定义 Swift 宏（Macro） 是一种在编译期执行的代码生成机制。开发者可以通过简洁的语法标记，在源代码中自动插入、替换或补充逻辑，从而实现样板代码的自动化。 Swift 宏建立在语法树

Swift 宏（Macro）对许多开发者来说，是一种既熟悉又陌生的工具。在 Objective-C 时代，我们经常使用 #define、条件编译、日志封装，甚至自动插桩来提升开发效率。这些基于 C 的

基础篇

Swift Macros - 宏之起点

本文介绍了 Swift 宏 的背景与引入动机，阐述了宏在编程中的基本用途，帮助开发者理解宏如何简化代码编写、提升开发效率。内容还包括了宏的基本配置方式与使用场景，适合入门读者对宏有一个初步的了解。

查看详情

Swift Macros - 宏之全貌

这篇文章从宏的类型体系、执行原理到角色机制和协议模型，为读者提供了一个宏系统的全景鸟瞰。文章介绍了宏在 Swift 中的不同角色及其协议关系，阐述了宏的扩展、展开过程以及如何结合协议实现多角色配合，帮助有一定基础的开发者全面理解宏的设计和应用。

查看详情

Swift Macros - 宏之职责与命名

本篇文章聚焦 Swift 宏系统中的“职责控制”与“命名控制”机制，系统讲解宏的三大核心组成：宏类型（Macro Kind） 、宏角色（Macro Role） 和 命名说明符（Name Specifier） 。通过区分独立宏与绑定宏、梳理各类宏角色，并结合命名说明符的使用方式，帮助开发者构建更清晰、稳定、可维护的宏能力体系。

查看详情

Swift Macros - 宏之语法树

本篇文章聚焦 Swift 宏系统中的“语法基础”与“结构操控”能力，深入剖析宏所操作的核心结构——语法节点（Syntax） 。通过讲解 SwiftSyntax 的节点体系、语法树的提取与构造方式、以及 (raw:) 插值的正确用法，帮助开发者掌握宏展开背后的语法逻辑与生成原理，为构建结构化、类型安全的宏能力奠定坚实基础。

查看详情

Swift Macros - 宏之节点指南

本文梳理了 SwiftSyntax 中常用的语法节点，涵盖表达式、声明、语句、类型、模式、属性、宏以及其他常用节点。每个节点均提供简要描述和快速构造示例，旨在为开发者在使用 Swift 宏和 SwiftSyntax 进行代码生成、分析和转换时，提供一份高效、准确的参考资料。

查看详情

Swift Macros - 宏之协议

Swift 宏系统通过不同的协议定义了宏的多种角色和能力，从表达式生成、声明插入，到成员绑定、访问控制等。本系列文章将逐个讲解这些协议的定义、特性及适用场景，帮助你系统理解宏的角色体系。

1.宏协议概述

简要介绍 Swift 中所有宏协议的概念、作用及它们之间的关系，作为理解整个宏协议体系的入口。 查看详情

2.表达式独立宏（ExpressionMacro）

讲解 ExpressionMacro 协议的定义与使用场景，展示如何基于表达式节点生成动态代码。

查看详情

3.声明式独立宏（DeclarationMacro）

分析 DeclarationMacro 如何生成声明代码，结合初始化器、变量、函数的实际生成场景讲解。

查看详情

4.成员绑定宏（MemberMacro）

展示 MemberMacro 如何为结构体或类动态插入属性、方法等成员内容，是构建派生代码的核心手段。

查看详情

5.对等绑定宏（PeerMacro）

说明 PeerMacro 的用途，即在同一层级下生成兄弟声明，常用于生成辅助类型或伴生属性等。

查看详情

6.访问器宏（AccessorMacro）

讲解 AccessorMacro 如何为现有的属性生成 getter/setter 等访问逻辑，结合 UserDefault 等场景展开。

查看详情

7.扩展宏（ExtensionMacro）

展示 ExtensionMacro 用于生成扩展声明，实现协议适配、默认实现等功能。

查看详情

8.属性宏（MemberAttributeMacro）

讲解 MemberAttributeMacro 的应用，如为属性自动添加注解、权限、内联标识等修饰语。

查看详情

9.方法体宏（BodyMacro）

说明 BodyMacro 的设计方式，以及如何为已有函数添加函数体代码，常用于方法插桩与默认实现生成。

查看详情