0Pricing
Swift Academy · Aula

Como escrever uma macro de expressão independente

Implemente uma macro #stringify simples com SwiftSyntax e MacroExpansion.

Como escrever uma macro de expressão independente é uma aula grátis de Swift Academy no CoddyKit. Esta é a aula 2 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Swift Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Swift Academy inclui 4 aulas no total.

Configuração do projeto

As macros ficam em um destino separado de pacote Swift do tipo .macro, usando SwiftSyntax.

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

Declaração da macro

Declare a assinatura da macro em um destino de biblioteca para que os clientes possam chamá-la.

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

Implementando o tipo da macro

Implemente a macro fazendo-a estar em conformidade com ExpressionMacro e devolvendo um ExprSyntax.

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))"
  }
}

Registrando o plug-in

Crie um CompilerPlugin que liste todas as macros do pacote.

import SwiftCompilerPlugin

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

Usando a macro

Importe a biblioteca de macros e chame-a usando #stringify.

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

Construção de ExprSyntax

Os valores de retorno são construídos usando interpolação de cadeias de caracteres em ExprSyntax, aproveitando a segurança de tipos do SwiftSyntax.

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

Acessando os argumentos da macro

Os argumentos são acessados por meio de node.arguments, que é uma lista de expressões rotuladas.

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

Gerando diagnósticos

Emita avisos ou erros do compilador a partir das macros usando o contexto de expansão.

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

Nós de sintaxe do SwiftSyntax

O SwiftSyntax representa cada construção da linguagem como um nó de sintaxe tipado que você pode inspecionar e construir.

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

Higiene das macros

As macros do Swift são higiênicas por padrão: os nomes gerados não entrarão em conflito com os nomes do escopo de chamada.

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

Expandindo no Xcode

Clique com o botão direito do mouse em qualquer chamada de macro no Xcode e escolha Expandir macro para inspecionar o código-fonte gerado.

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

Verificação rápida

Com qual protocolo uma implementação de macro de expressão deve estar em conformidade?

Recapitulação da lição

Escreva uma macro de expressão independente: declare-a com @freestanding(expression), implemente ExpressionMacro em um destino .macro, registre-a por meio de CompilerPlugin e chame-a com #macroName().

Perguntas Frequentes

A aula “Como escrever uma macro de expressão independente” é grátis?

Sim — o texto completo de “Como escrever uma macro de expressão independente” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Swift Academy, atualize para CoddyKit PRO. O curso de Swift Academy inclui 4 aulas no total.

O que vou aprender em “Como escrever uma macro de expressão independente”?

Implemente uma macro #stringify simples com SwiftSyntax e MacroExpansion. Você pratica Swift Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Swift Academy?

Nenhuma experiência prévia é necessária. Swift Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 4.

Quanto tempo leva a aula “Como escrever uma macro de expressão independente”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Swift Academy?

Sim. Cada aula de Swift Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Funções das macros: independentes e anexadas
  2. Como escrever uma macro de expressão independente
  3. Macros de membros anexadas para reduzir código repetitivo
  4. Testes e depuração de macros
← Voltar para Swift Academy