Escritura de una macro de expresión independiente

Configuración del proyecto

// Package.swift (excerpt)
.macro(
  name: "MyMacros",
  dependencies: [
    .product(name: "SwiftSyntaxMacros", package: "swift-syntax"),
    .product(name: "SwiftCompilerPlugin", package: "swift-syntax")
  ]
)

Declaración de la macro

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

Implementación del tipo de macro

import SwiftSyntaxMacros
import SwiftSyntax

struct StringifyMacro: ExpressionMacro {
  static func expansion(
    of node: some FreestandingMacroExpansionSyntax,
    in context: some MacroExpansionContext
  ) throws -> ExprSyntax {
    guard let arg = node.arguments.first?.expression else {
      throw MacroError.message("Need an argument")
    }
    return "(\(arg), \(literal: arg.description))"
  }
}

Registro del plugin

import SwiftCompilerPlugin

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

Uso de la macro

import MyMacros
let (value, source) = #stringify(2 + 3)
print(value)   // 5
print(source)  // "2 + 3"

Construcción de ExprSyntax

// The expansion returns a tuple literal
return "((\(arg)), \(literal: arg.description))"

Acceso a los argumentos de la macro

let args = node.arguments
for arg in args {
  print(arg.label?.text ?? "_", arg.expression)
}

Generación de diagnósticos

context.diagnose(Diagnostic(
  node: node,
  message: MyDiagnostic.missingArgument
))

Nodos de sintaxis de SwiftSyntax

import SwiftSyntax
let expr: ExprSyntax = "1 + 2"
print(type(of: expr)) // BinaryOperatorExprSyntax

Higiene de macros

// Macro-generated variables get unique names internally
// preventing accidental shadowing in user code

Expansión en Xcode

#stringify(40 + 2)
// Xcode expands to: (40 + 2, "40 + 2")

Comprobación rápida

Resumen de la lección