1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

import Observation

@Observable
final class Model {
    var count = 0
    var name = "x"
}

let model = Model()
model.count += 1
print(model.count, model.name)
// prints: 1 x

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

$ swiftc -typecheck -Xfrontend -dump-macro-expansions demo.swift
@__swiftmacro_4demo5Model10ObservablefMm_.swift
------------------------------
@ObservationIgnored private let _$observationRegistrar = Observation.ObservationRegistrar()

internal nonisolated func access<Member>(
  keyPath: KeyPath<Model, Member>
) {
  _$observationRegistrar.access(self, keyPath: keyPath)
}

1

$ swift package init --type macro

1
2
3

@freestanding(expression)
public macro stringify<T>(_ value: T) -> (T, String) =
    #externalMacro(module: "MacroDemoMacros", type: "StringifyMacro")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

import SwiftCompilerPlugin
import SwiftSyntax
import SwiftSyntaxBuilder
import SwiftSyntaxMacros

public struct StringifyMacro: ExpressionMacro {
    public static func expansion(
        of node: some FreestandingMacroExpansionSyntax,
        in context: some MacroExpansionContext
    ) -> ExprSyntax {
        guard let argument = node.arguments.first?.expression else {
            fatalError("宏没拿到参数")
        }
        return "(\(argument), \(literal: argument.description))"
    }
}

1
2

@attached(member, names: named(kind))
public macro Kind() = #externalMacro(module: "MacroDemoMacros", type: "KindMacro")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

import SwiftSyntaxMacros

public struct KindMacro: MemberMacro {
    public static func expansion(
        of node: AttributeSyntax,
        providingMembersOf declaration: some DeclGroupSyntax,
        conformingTo protocols: [TypeSyntax],          // ← 新签名多出来的参数
        in context: some MacroExpansionContext
    ) throws -> [DeclSyntax] {
        ["static var kind: String { String(describing: Self.self) }"]
    }
}

1
2
3

warning: deprecated default implementation is used to satisfy static method
'expansion(of:providingMembersOf:conformingTo:in:)' required by protocol 'MemberMacro':
`MemberMacro` conformance should implement the `expansion` function that takes a `conformingTo` parameter [#DeprecatedDeclaration]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

import SwiftCompilerPlugin
import SwiftSyntaxMacros

@main
struct MacroDemoPlugin: CompilerPlugin {
    let providingMacros: [Macro.Type] = [
        StringifyMacro.self,
        KindMacro.self,
    ]
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

import MacroDemo

let a = 17
let b = 25
let (result, code) = #stringify(a + b)
print("The value \(result) was produced by the code \"\(code)\"")
// prints: The value 42 was produced by the code "a + b"

@Kind
struct Config { var name = "默认"; var retries = 3 }

print(Config.kind, Config().name)
// prints: Config 默认

1
2
3
4
5
6
7

func average(_ numbers: [Int]) -> Double {
    precondition(!numbers.isEmpty, "空数组没有平均值")
    return Double(numbers.reduce(0, +)) / Double(numbers.count)
}

print(average([1, 2, 3]))
// prints: 2.0

1
2

$ ./demo
demo/demo.swift:2: Precondition failed: 空数组没有平均值

1
2
3
4
5
6

struct Point { var x = 1; var y = 2 }

print(Point())
// prints: Point(x: 1, y: 2)
print(String(describing: Point()))
// prints: Point(x: 1, y: 2)

1
2
3
4
5
6

$ swift demo.swift
Point(x: 1, y: 2)            ← print / String(describing:)
demo.Point(x: 1, y: 2)       ← debugPrint / String(reflecting:)，会把模块名带上
▿ demo.Point                 ← dump：递归展开层级
  - x: 1
  - y: 2

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

struct Inner { var a = 1 }
struct Outer { var i = Inner(); var b = 2 }

dump(Outer())
// ▿ demo.Outer
//   ▿ i: demo.Inner
//     - a: 1
//   - b: 2

print(String(reflecting: Outer()))
// demo.Outer(i: demo.Inner(a: 1), b: 2)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

struct Money: CustomStringConvertible, CustomDebugStringConvertible {
    var cents: Int
    var description: String { "¥\(Double(cents) / 100)" }
    var debugDescription: String { "Money(cents: \(cents))" }
}

let m = Money(cents: 1250)
print(m)
// prints: ¥12.5
debugPrint(m)
// prints: Money(cents: 1250)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

import Foundation

@available(macOS 13, *)
func newOnly() -> Int { 1 }
print(newOnly())
// prints: 1

struct Hidden {
    @warn_unqualified_access func value() -> Int { 1 }
    static func value() -> Int { 2 }
}
print(Hidden().value(), Hidden.value())
// prints: 1 2

1
2
3
4
5

extension Int: @retroactive Identifiable {   // Int 与 Identifiable 都不是本模块的
    public var id: Int { self }
}
print(5.id)
// prints: 5