Close #14: dispatch freestanding macros to host handlers; host-registered attributes (@Test/@Suite)

[odrobnik]

Closes #14.

Parsing needed nothing — swift-syntax already parses #name(args…) in every position the issue cares about (top level, statement position, inside a try binding all produce MacroExpansionExprSyntax), and operator folding already reaches inside macro arguments. What was missing was evaluation, and this PR adds both halves the issue sketched.

Freestanding macros

evaluate(macroExpansion:) dispatches #name(args…) to a handler registered in the bridge table under the issue's key shape:

interpreter.registerMacro("expect") { args in … }   // bridges["macro #expect"] = .macro { … }

The handler receives each argument as a MacroArgument — label / value / sourceText — one struct instead of the issue's two parallel arrays, because labels turn out to matter (sourceLocation:, arguments:) and the same shape then serves attribute arguments unchanged. sourceText is the exact source spelling, so #expect(a == b) reports false and "a == b".

• #expect semantics: record into host state, return .void, the run continues.
• #require semantics: throw — the handler call routes through callingBridge (Errors thrown from bridges cannot be caught by script do/catch #12/Close #11/#12: defer leading-dot member args to the callee; make bridge errors catchable #13 machinery), so the error is catchable by script do/catch and try?, and try #require(…) reads naturally.
• Trailing closures fold into the argument list (#expect(throws:) { … } arrives as two arguments).
• Leading-dot arguments defer to the handler as unresolved markers — the Implicit member access (.any) is unsupported, blocking verbatim Apple-shaped calls #11 rule, since the macro's parameter types live on the host.
• Unregistered #name stays a hard error, now with stock swiftc's wording: no macro named 'expect' (new RuntimeError.noMacro). Generic argument clauses are refused loudly.

Host-registered attributes

interpreter.registerAttribute("Test")               // preflight no longer refuses @Test
interpreter.declarations(withAttribute: "Test")     // -> [AttributedDeclaration]
interpreter.call(decl.invocable!)                   // run one

The unsupported-attribute preflight now exempts registered names (everything else keeps failing exactly as before). Declarations carrying a registered attribute are recorded with their arguments evaluated to Values — @Test("display name") arrives as a .string; implicit-member forms (.disabled("flaky"), nested .tags(.critical)) arrive as unresolved enum markers for the host to interpret, extending the defer-to-the-callee principle to attribute arguments; @Test(arguments: [1, 2, 3]) arrives labeled so the host can drive the parameterized run itself. @Test funcs carry an invocable .function; @Suite types are recorded without one.

The end-to-end test pastes the issue's target shape in and runs it unmodified:

import Testing

@Test func math() async throws {
    #expect(1 + 1 == 3)                 // recorded, run continues
    let n = try #require(Int("21"))     // unwraps
    #expect(n * 2 == 42)
}

Also: member-position macros no longer vanish

struct S { #foo("x") } used to load silently, dropping the member — the exact plausible-wrong-behavior class the preflight exists to prevent. All four member walks (struct/class/enum/extension) now refuse freestanding macros in member position loudly. The broader family of silently-dropped member declarations (nested types, typealiases, indexed subscripts) is filed separately as #18.

Out of scope (follow-ups)

• Enumerating @Test methods inside @Suite types (top-level @Test funcs are the enumerable form for now; suites load and are recorded).
• The richer decomposed-operand reporting (a == b → both operand values) — sourceText covers the common case, and the folded infix node makes this a straightforward later step.

Tests

17 new tests in two suites (MacroExpansionTests, HostAttributeTests) covering dispatch positions, source-text fidelity, catchability, labels, trailing closures, implicit-member deferral, parameterized invocation, re-eval replacement, and all three hard-error paths. Full suite: 558 tests in 62 suites pass, probe-conformance goldens included.

🤖 Generated with Claude Code

[chatgpt-codex-connector]

💡 Codex Review

Here are some automated review suggestions for this pull request.

Reviewed commit: f06a03a4e3

ℹ️ About Codex in GitHub

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

• Open a pull request for review
• Mark a draft as ready
• Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

Codex can also answer questions or update the PR. Try commenting "@codex address that feedback".