Macros are incredibly powerful, but they come with a specific kind of frustration: when they break, the compiler usually yells at the line where you applied the macro, not the line in your macro implementation where you actually messed up the syntax. It's like being told your house is on fire, but the fire is actually in a hidden crawlspace you didn't know existed.

I've seen this a dozen times. You're building a @Logged macro to wrap function bodies in print statements, you hit Cmd+B, and suddenly you get a generic Expected '}' in closure or Consecutive declarations on a line must be separated by ';'. The error points to your class definition, but your class definition looks perfect. The bug is hiding in the generated code.

The Mystery of the Vanishing Brace

Take a look at this snippet. I'm trying to build a @PropertyWrapperLog macro that generates a helper method to print the value of a property. It's supposed to look like this:

struct User {
    @PropertyWrapperLog var name: String = "Alice"
    // Macro should generate: func logName() { print("name: \(name)") }
}

But instead, I'm getting this compiler error pointing directly at the @PropertyWrapperLog line:
"Expected declaration".

If I look at my macro implementation, I'm manually constructing the DeclSyntax. Here is the culprit:

// Inside the Macro implementation
let methodName = "log\(capitalizedName)()"
return [
    "func \(methodName) { print(\"\(propertyName): \\(self.\(propertyName))\")"
    // Wait... where is the closing brace?
]

In a standard Swift file, forgetting a closing brace is obvious. But inside a macro, you're essentially writing code that writes code. The compiler expands the macro, injects the broken string into your source, and then the result fails to compile. Because the source of the injection is the attribute, that's where the error marker lands. It's a total guessing game if you don't know how to see the expanded result.

Peeking Under the Hood with Expand Macro

You should almost never try to debug macro syntax by "guessing" what the string looks like. Xcode has a built-in tool specifically for this.

Right-click on the macro attribute (e.g., @PropertyWrapperLog) in your source code. In the menu, you'll see Expand Macro. When you click this, Xcode replaces the attribute with the actual code the macro generated. It's a temporary view, but it's the only way to see exactly what your Syntax trees are producing.

When I did this for the example above, I saw the generated code:
func logName() { print("name: \(self.name)")

The missing } became immediately obvious. The "Expected declaration" error was simply the compiler saying, "I started reading a function, but I hit the end of the struct before the function ever finished."

Fixing the Syntax Tree Leak

The fix is simple—add the brace—but the better fix is to stop relying on raw strings for complex expansions. I usually prefer using SwiftSyntax's specialized types or, at the very least, multi-line string literals to make the structure visible to my own eyes.

// The fixed, more readable version
let body = "print(\"\(propertyName): \\(self.\(propertyName))\")"
return [
    """
    func log\(capitalizedName)() {
        \(body)
    }
    """
]

Now, when I rebuild, the error vanishes. I've verified it by expanding the macro again, and the braces are exactly where they need to be. I'll leave you with this: if you see a syntax error on a line that looks visually perfect, 99% of the time, a macro on that line is generating "garbage" code. Expand it first, then fix the implementation.

📋 Practical Task

Repairing the Broken @Coordinate Macro

You are working on a project that uses a @Coordinate macro. This macro is intended to be placed on a struct to automatically generate a method called distance(to: x, y:) that calculates the distance between two points.

However, the project is currently failing to compile. The error "Consecutive declarations on a line must be separated by ';'" is appearing on the struct declaration, even though the struct looks correct.

Your Task:

1. Analyze the provided macro implementation below.
2. Identify the syntax error being generated in the distance method expansion.
3. Correct the string interpolation so that the generated method is syntactically valid Swift.

// BUGGY MACRO IMPLEMENTATION
public struct CoordinateMacro: MemberMacro {
    public static func expansion(
        of node: SomeMacroExpansion,
        in context: SomeMacroExpansionContext
    ) throws -> [DeclSyntax] {
        return [
            """
            func distance(toX x: Double, toY y: Double) -> Double {
                sqrt(pow(x - self.x, 2) + pow(y - self.y, 2)
            }
            """
        ]
    }
}