@soundscript/soundscript 0.1.13 → 0.1.15

package/project-transform/src/frontend/macro_context.js

@@ -0,0 +1,816 @@
+import { createAnnotationLookup } from '../annotation_syntax.js';
+import { normalizeRuntimeContext } from '../config.js';
+import { pathExistsSync, readBytesSync, readTextFileSync, runtimeEnv } from '../platform/host.js';
+import { dirname, isAbsolute, join, normalize } from '../platform/path.js';
+import { createMacroError } from './macro_errors.js';
+import { parseSingleHostStatement, synthesizeHostNode, } from './macro_host_ast_internal.js';
+import { buildArrowFunctionExprSyntax, buildAssignmentExprSyntax, buildBinaryExprSyntax, buildBlockSyntax, buildBooleanLiteralExprSyntax, buildCallExprSyntax, buildClassFieldSyntax, buildClassGetterSyntax, buildClassMethodSyntax, buildClassSetterSyntax, buildConstDeclStmtSyntax, buildElementAccessExprSyntax, buildExprStmtSyntax, buildForStmtSyntax, buildFunctionDeclSyntax, buildIdentifierExprSyntax, buildIfStmtSyntax, buildLetDeclStmtSyntax, buildNewExprSyntax, buildNullLiteralExprSyntax, buildNumberLiteralExprSyntax, buildObjectLiteralExprSyntax, buildOptionalMethodCallExprSyntax, buildPropertyAccessExprSyntax, buildReturnStmtSyntax, buildStringLiteralExprSyntax, buildThisExprSyntax, buildThrowStmtSyntax, buildUnaryExprSyntax, createArgumentSyntaxFromText, createBareArgumentSyntax, createBlockSyntaxFromText, createClassMemberSyntaxListFromCode, createDeclSyntaxFromText, createExprSyntaxFromText, createInvocationSyntax, createStmtListSyntaxFromCode, createStmtSyntaxFromNode, getHostExpression, getHostNode, getHostStatement, quoteText, updateClassSyntax, } from './macro_syntax_internal.js';
+import { createMacroExprOutput, createMacroStmtListOutput, createMacroStmtOutput, } from './macro_output.js';
+import { parseTemplateOperand } from './macro_templates.js';
+const DEFAULT_MACRO_RUNTIME_CONTEXT = normalizeRuntimeContext({
+    externs: [],
+    target: 'js-node',
+});
+function sanitizeBindingHint(hint) {
+    const sanitized = hint.replace(/[^A-Za-z0-9_$]/g, '_');
+    return sanitized.length > 0 ? sanitized : '__sts_macro_tmp';
+}
+function createFreshBindingFactory(seed) {
+    let counter = 0;
+    return {
+        binding(hint) {
+            counter += 1;
+            return `${sanitizeBindingHint(hint)}_${seed}_${counter}`;
+        },
+    };
+}
+function createUnsupportedHostAccess(reason) {
+    const fail = () => {
+        throw new Error(reason);
+    };
+    return {
+        env: {
+            get() {
+                return fail();
+            },
+            require() {
+                return fail();
+            },
+        },
+        fs: {
+            exists() {
+                return fail();
+            },
+            readBytes() {
+                return fail();
+            },
+            readText() {
+                return fail();
+            },
+        },
+    };
+}
+function resolveHostPath(path, options, base = 'macro') {
+    if (isAbsolute(path)) {
+        throw new Error(`Macro host path "${path}" must be relative to the macro module or project root. Absolute host paths are not supported.`);
+    }
+    const root = base === 'project' ? options.projectDirectory : dirname(options.macroFileName);
+    return normalize(join(root, path));
+}
+export function createHostAccess(options) {
+    const textEncoder = new TextEncoder();
+    const envSnapshot = options.env ??
+        globalThis.__STS_MACRO_ENV__;
+    return {
+        env: {
+            get(name) {
+                return envSnapshot ? envSnapshot[name] : runtimeEnv(name);
+            },
+            require(name) {
+                const value = envSnapshot ? envSnapshot[name] : runtimeEnv(name);
+                if (value === undefined) {
+                    throw new Error(`Macro host environment variable "${name}" is not set.`);
+                }
+                return value;
+            },
+        },
+        fs: {
+            exists(path, pathOptions = {}) {
+                const resolvedPath = resolveHostPath(path, options, pathOptions.base);
+                if (options.fileExists) {
+                    return options.fileExists(resolvedPath);
+                }
+                return pathExistsSync(resolvedPath);
+            },
+            readBytes(path, pathOptions = {}) {
+                const resolvedPath = resolveHostPath(path, options, pathOptions.base);
+                const bytes = options.readBytes?.(resolvedPath);
+                if (bytes !== undefined) {
+                    return bytes;
+                }
+                const text = options.readFile?.(resolvedPath);
+                if (text !== undefined) {
+                    return textEncoder.encode(text);
+                }
+                return readBytesSync(resolvedPath);
+            },
+            readText(path, pathOptions = {}) {
+                const resolvedPath = resolveHostPath(path, options, pathOptions.base);
+                const text = options.readFile?.(resolvedPath);
+                if (text !== undefined) {
+                    return text;
+                }
+                return readTextFileSync(resolvedPath);
+            },
+        },
+    };
+}
+function createUnsupportedRuntimeAccess(reason, runtimeContext) {
+    return {
+        backend: runtimeContext.backend,
+        default() {
+            throw new Error(reason);
+        },
+        externs() {
+            return [...runtimeContext.externs];
+        },
+        host: runtimeContext.host,
+        named() {
+            throw new Error(reason);
+        },
+        namespace() {
+            throw new Error(reason);
+        },
+        target: runtimeContext.target,
+    };
+}
+function createRuntimeTracker(build, runtimeResolver, runtimeContext) {
+    if (!runtimeResolver) {
+        return {
+            access: createUnsupportedRuntimeAccess('This macro requires runtime import resolution, but no prepared program or macro module metadata was available.', runtimeContext),
+            snapshot() {
+                return [];
+            },
+        };
+    }
+    const activeRuntimeResolver = runtimeResolver;
+    const byKey = new Map();
+    function record(kind, specifier, exportName) {
+        const resolved = activeRuntimeResolver.resolve({ exportName, kind, specifier });
+        byKey.set(`${resolved.kind}\u0000${resolved.specifier}\u0000${resolved.exportName ?? ''}`, resolved);
+        return build.identifier(resolved.localName);
+    }
+    return {
+        access: {
+            backend: runtimeContext.backend,
+            default(specifier) {
+                return record('default', specifier);
+            },
+            externs() {
+                return [...runtimeContext.externs];
+            },
+            host: runtimeContext.host,
+            named(specifier, exportName) {
+                return record('named', specifier, exportName);
+            },
+            namespace(specifier) {
+                return record('namespace', specifier);
+            },
+            target: runtimeContext.target,
+        },
+        snapshot() {
+            return [...byKey.values()];
+        },
+    };
+}
+function sliceSpan(text, span) {
+    return text.slice(span.start, span.end);
+}
+function getLineAndColumn(text, position) {
+    let line = 1;
+    let column = 1;
+    for (let index = 0; index < position; index += 1) {
+        if (text[index] === '\n') {
+            line += 1;
+            column = 1;
+        }
+        else {
+            column += 1;
+        }
+    }
+    return { column, line };
+}
+function attachedAnnotationsForNode(node) {
+    const hostNode = getHostNode(node);
+    return hostNode
+        ? createAnnotationLookup(hostNode.getSourceFile()).getAttachedAnnotations(hostNode)
+        : [];
+}
+function toInvocationForm(invocation) {
+    switch (invocation.invocationKind) {
+        case 'block':
+            return 'block';
+        case 'arglist':
+            return 'arglist';
+        case 'arglist+block':
+            return 'arglist';
+        case 'decl':
+            return 'decl';
+        case 'arglist+decl':
+            return 'arglist_decl';
+    }
+}
+function getPrimaryExprSpan(invocation) {
+    if (getBlockSpan(invocation) || getDeclarationSpan(invocation)) {
+        return undefined;
+    }
+    const expressionArguments = invocation.argumentSpans.filter((argument) => argument.kind === 'ExprArg');
+    if (expressionArguments.length !== 1 ||
+        expressionArguments.length !== invocation.argumentSpans.length) {
+        return undefined;
+    }
+    return expressionArguments[0]?.span;
+}
+function getBlockSpan(invocation) {
+    if (invocation.trailingBlockSpan) {
+        return invocation.trailingBlockSpan;
+    }
+    if (invocation.invocationKind === 'block') {
+        const [firstArgument] = invocation.argumentSpans;
+        if (firstArgument?.kind === 'BlockArg') {
+            return firstArgument.span;
+        }
+    }
+    return undefined;
+}
+function getDeclarationSpan(invocation) {
+    return invocation.declarationSpan;
+}
+function createInvocationView(invocation, originalText) {
+    const normalizedArguments = invocation.argumentSpans.filter((argument) => argument.kind === 'ExprArg');
+    const args = normalizedArguments.map((argument, index) => createBareArgumentSyntax(index, argument.span, sliceSpan(originalText, argument.span)));
+    return {
+        args,
+        form: toInvocationForm(invocation),
+        hasBlock: getBlockSpan(invocation) !== undefined,
+        name: invocation.nameText,
+    };
+}
+function createQuoteFactory(fileName) {
+    function interpolate(strings, values) {
+        let output = '';
+        for (let index = 0; index < strings.length; index += 1) {
+            output += strings[index] ?? '';
+            if (index < values.length) {
+                output += quoteText(values[index]);
+            }
+        }
+        return output;
+    }
+    return {
+        block(strings, ...values) {
+            const code = interpolate(strings, values);
+            return createBlockSyntaxFromText(fileName, { fileName, start: 0, end: code.length }, code);
+        },
+        classMembers(strings, ...values) {
+            const code = interpolate(strings, values);
+            return createClassMemberSyntaxListFromCode(fileName, code);
+        },
+        decl(strings, ...values) {
+            const code = interpolate(strings, values);
+            return createDeclSyntaxFromText(fileName, { fileName, start: 0, end: code.length }, code);
+        },
+        expr(strings, ...values) {
+            const code = interpolate(strings, values);
+            return createExprSyntaxFromText(fileName, { fileName, start: 0, end: code.length }, code);
+        },
+        stmt(strings, ...values) {
+            const code = interpolate(strings, values);
+            const statement = parseSingleHostStatement(fileName, 'macro_quote_stmt', code, 'Quoted macro statements must parse as exactly one host-language statement.');
+            return createStmtSyntaxFromNode(statement, statement.getSourceFile(), { fileName, start: 0, end: code.length });
+        },
+        stmts(strings, ...values) {
+            const code = interpolate(strings, values);
+            return createStmtListSyntaxFromCode(fileName, 'macro_quote_stmt_list', code);
+        },
+    };
+}
+function createBuildFactory(fileName) {
+    return {
+        assign(target, value) {
+            return buildAssignmentExprSyntax(fileName, target, value);
+        },
+        arrowFunction(parameters, body) {
+            return buildArrowFunctionExprSyntax(fileName, parameters, body);
+        },
+        binary(left, operator, right) {
+            return buildBinaryExprSyntax(fileName, left, operator, right);
+        },
+        block(statements) {
+            return buildBlockSyntax(fileName, statements);
+        },
+        booleanLiteral(value) {
+            return buildBooleanLiteralExprSyntax(fileName, value);
+        },
+        call(callee, args) {
+            return buildCallExprSyntax(fileName, callee, args);
+        },
+        constDecl(name, initializer) {
+            return buildConstDeclStmtSyntax(fileName, name, initializer);
+        },
+        element(object, index) {
+            return buildElementAccessExprSyntax(fileName, object, index);
+        },
+        exprStmt(expression) {
+            return buildExprStmtSyntax(fileName, expression);
+        },
+        field(options) {
+            return buildClassFieldSyntax(fileName, options);
+        },
+        forStmt(options) {
+            return buildForStmtSyntax(fileName, options);
+        },
+        identifier(name) {
+            return buildIdentifierExprSyntax(fileName, name);
+        },
+        ifStmt(options) {
+            return buildIfStmtSyntax(fileName, options);
+        },
+        functionDecl(options) {
+            return buildFunctionDeclSyntax(fileName, options);
+        },
+        getter(options) {
+            return buildClassGetterSyntax(fileName, options);
+        },
+        letDecl(name, initializer) {
+            return buildLetDeclStmtSyntax(fileName, name, initializer);
+        },
+        method(options) {
+            return buildClassMethodSyntax(fileName, options);
+        },
+        newExpr(callee, args) {
+            return buildNewExprSyntax(fileName, callee, args);
+        },
+        nullLiteral() {
+            return buildNullLiteralExprSyntax(fileName);
+        },
+        numberLiteral(value) {
+            return buildNumberLiteralExprSyntax(fileName, value);
+        },
+        objectLiteral(members) {
+            return buildObjectLiteralExprSyntax(fileName, members);
+        },
+        optionalMethodCall(receiver, name, args) {
+            return buildOptionalMethodCallExprSyntax(fileName, receiver, name, args);
+        },
+        property(object, name) {
+            return buildPropertyAccessExprSyntax(fileName, object, name);
+        },
+        returnStmt(expression) {
+            return buildReturnStmtSyntax(fileName, expression);
+        },
+        setter(options) {
+            return buildClassSetterSyntax(fileName, options);
+        },
+        stringLiteral(value) {
+            return buildStringLiteralExprSyntax(fileName, value);
+        },
+        thisExpr() {
+            return buildThisExprSyntax(fileName);
+        },
+        throwStmt(expression) {
+            return buildThrowStmtSyntax(fileName, expression);
+        },
+        unary(operator, value) {
+            return buildUnaryExprSyntax(fileName, operator, value);
+        },
+        updateClass(base, members) {
+            return updateClassSyntax(base, members);
+        },
+    };
+}
+function createOutputFactory(runtimeTracker) {
+    return {
+        expr(node) {
+            return createMacroExprOutput(synthesizeHostNode(getHostExpression(node)), runtimeTracker.snapshot());
+        },
+        stmt(node) {
+            return createMacroStmtOutput(synthesizeHostNode(getHostStatement(node)), runtimeTracker.snapshot());
+        },
+        stmts(nodes) {
+            return createMacroStmtListOutput(nodes.map((node) => synthesizeHostNode(getHostStatement(node))), runtimeTracker.snapshot());
+        },
+    };
+}
+export function createMacroContext(resolved, runtimeResolver = null, hostAccess = createUnsupportedHostAccess('This macro requires compile-time host access, but no prepared program or macro module metadata was available.'), runtimeContext = DEFAULT_MACRO_RUNTIME_CONTEXT) {
+    const invocation = resolved.placeholder.invocation;
+    const originalText = resolved.placeholder.preparedFile.originalText;
+    const invocationView = createInvocationView(invocation, originalText);
+    const parsedTemplateArgs = new Map();
+    const parsedExprArgs = new Map();
+    let parsedBlockSyntax;
+    let parsedDeclarationSyntax;
+    let parsedInvocationSyntax = null;
+    const fresh = createFreshBindingFactory(String(resolved.placeholder.id));
+    const build = createBuildFactory(invocation.span.fileName);
+    const quote = createQuoteFactory(invocation.span.fileName);
+    const runtimeTracker = createRuntimeTracker(build, runtimeResolver, runtimeContext);
+    const output = createOutputFactory(runtimeTracker);
+    const parseTemplateArgForContext = (index) => {
+        if (parsedTemplateArgs.has(index)) {
+            return parsedTemplateArgs.get(index) ?? null;
+        }
+        const argument = invocationView.args[index];
+        const parsed = argument ? parseTemplateOperand(argument.span, argument.text()) : null;
+        parsedTemplateArgs.set(index, parsed);
+        return parsed;
+    };
+    const parseExprArgForContext = (index) => {
+        const existing = parsedExprArgs.get(index);
+        if (existing) {
+            return existing;
+        }
+        const argument = invocationView.args[index];
+        if (!argument) {
+            throw new Error(`Macro "${invocation.nameText}" argument ${index} is out of range.`);
+        }
+        const syntax = createArgumentSyntaxFromText(index, invocation.span.fileName, argument.span, argument.text());
+        parsedExprArgs.set(index, syntax);
+        return syntax;
+    };
+    const parseBlockSyntaxForContext = () => {
+        if (parsedBlockSyntax !== undefined) {
+            if (parsedBlockSyntax === null) {
+                throw new Error(`Macro "${invocation.nameText}" does not have a block argument.`);
+            }
+            return parsedBlockSyntax;
+        }
+        const blockSpan = getBlockSpan(invocation);
+        if (!blockSpan) {
+            parsedBlockSyntax = null;
+            throw new Error(`Macro "${invocation.nameText}" does not have a block argument.`);
+        }
+        parsedBlockSyntax = createBlockSyntaxFromText(invocation.span.fileName, blockSpan, sliceSpan(originalText, blockSpan));
+        return parsedBlockSyntax;
+    };
+    const parseDeclarationSyntaxForContext = () => {
+        if (parsedDeclarationSyntax !== undefined) {
+            if (parsedDeclarationSyntax === null) {
+                throw new Error(`Macro "${invocation.nameText}" does not have a declaration argument.`);
+            }
+            return parsedDeclarationSyntax;
+        }
+        const declarationSpan = getDeclarationSpan(invocation);
+        if (!declarationSpan) {
+            parsedDeclarationSyntax = null;
+            throw new Error(`Macro "${invocation.nameText}" does not have a declaration argument.`);
+        }
+        parsedDeclarationSyntax = createDeclSyntaxFromText(invocation.span.fileName, declarationSpan, sliceSpan(originalText, declarationSpan));
+        return parsedDeclarationSyntax;
+    };
+    const parseInvocationSyntaxForContext = () => {
+        if (parsedInvocationSyntax) {
+            return parsedInvocationSyntax;
+        }
+        parsedInvocationSyntax = createInvocationSyntax({
+            args: invocationView.args.map((_, index) => parseExprArgForContext(index)),
+            block: getBlockSpan(invocation) ? parseBlockSyntaxForContext() : null,
+            declaration: getDeclarationSpan(invocation) ? parseDeclarationSyntaxForContext() : null,
+            form: invocationView.form,
+            hasBlock: invocationView.hasBlock,
+            name: invocation.nameText,
+            span: invocation.span,
+            text: sliceSpan(originalText, invocation.span),
+        });
+        return parsedInvocationSyntax;
+    };
+    return {
+        build,
+        fresh,
+        host: hostAccess,
+        invocation: invocationView,
+        kind: invocation.rewriteKind,
+        name: invocation.nameText,
+        output,
+        quote,
+        runtime: runtimeTracker.access,
+        syntax: {
+            annotations(node) {
+                return attachedAnnotationsForNode(node);
+            },
+            arg(index) {
+                return parseExprArgForContext(index);
+            },
+            args() {
+                return invocationView.args.map((_, index) => parseExprArgForContext(index));
+            },
+            block() {
+                return parseBlockSyntaxForContext();
+            },
+            declaration() {
+                return parseDeclarationSyntaxForContext();
+            },
+            primaryExpr() {
+                const exprSpan = getPrimaryExprSpan(invocation);
+                if (!exprSpan) {
+                    throw new Error(`Macro "${invocation.nameText}" does not have a primary expression argument.`);
+                }
+                return parseExprArgForContext(0);
+            },
+            root() {
+                return parseInvocationSyntaxForContext();
+            },
+            template(index) {
+                return parseTemplateArgForContext(index);
+            },
+        },
+        blockSpan() {
+            return getBlockSpan(invocation) ?? null;
+        },
+        declarationSpan() {
+            return getDeclarationSpan(invocation) ?? null;
+        },
+        error(message, node) {
+            throw createMacroError(resolved, message, node?.span);
+        },
+        hasBlock() {
+            return invocationView.hasBlock;
+        },
+        invocationSpan() {
+            return invocation.span;
+        },
+        location() {
+            const start = getLineAndColumn(originalText, invocation.span.start);
+            return {
+                column: start.column,
+                filePath: invocation.span.fileName,
+                line: start.line,
+            };
+        },
+        parsedSyntax() {
+            return parseInvocationSyntaxForContext();
+        },
+        runtimeImports() {
+            return runtimeTracker.snapshot();
+        },
+        sourceText() {
+            return sliceSpan(originalText, invocation.span);
+        },
+    };
+}
+export function createSyntaxOnlyMacroContext(invocation, originalText, runtimeContext = DEFAULT_MACRO_RUNTIME_CONTEXT) {
+    const base = (() => {
+        const invocationView = createInvocationView(invocation, originalText);
+        const parsedTemplateArgs = new Map();
+        const parsedExprArgs = new Map();
+        let parsedBlockSyntax;
+        let parsedDeclarationSyntax;
+        let parsedInvocationSyntax = null;
+        const fresh = createFreshBindingFactory(`${invocation.span.start}_${invocation.span.end}`);
+        const build = createBuildFactory(invocation.span.fileName);
+        const quote = createQuoteFactory(invocation.span.fileName);
+        const runtimeTracker = createRuntimeTracker(build, null, runtimeContext);
+        const output = createOutputFactory(runtimeTracker);
+        const parseTemplateArgForContext = (index) => {
+            if (parsedTemplateArgs.has(index)) {
+                return parsedTemplateArgs.get(index) ?? null;
+            }
+            const argument = invocationView.args[index];
+            const parsed = argument ? parseTemplateOperand(argument.span, argument.text()) : null;
+            parsedTemplateArgs.set(index, parsed);
+            return parsed;
+        };
+        const parseExprArgForContext = (index) => {
+            const existing = parsedExprArgs.get(index);
+            if (existing) {
+                return existing;
+            }
+            const argument = invocationView.args[index];
+            if (!argument) {
+                throw new Error(`Macro "${invocation.nameText}" argument ${index} is out of range.`);
+            }
+            const syntax = createArgumentSyntaxFromText(index, invocation.span.fileName, argument.span, argument.text());
+            parsedExprArgs.set(index, syntax);
+            return syntax;
+        };
+        const parseBlockSyntaxForContext = () => {
+            if (parsedBlockSyntax !== undefined) {
+                if (parsedBlockSyntax === null) {
+                    throw new Error(`Macro "${invocation.nameText}" does not have a block argument.`);
+                }
+                return parsedBlockSyntax;
+            }
+            const blockSpan = getBlockSpan(invocation);
+            if (!blockSpan) {
+                parsedBlockSyntax = null;
+                throw new Error(`Macro "${invocation.nameText}" does not have a block argument.`);
+            }
+            parsedBlockSyntax = createBlockSyntaxFromText(invocation.span.fileName, blockSpan, sliceSpan(originalText, blockSpan));
+            return parsedBlockSyntax;
+        };
+        const parseDeclarationSyntaxForContext = () => {
+            if (parsedDeclarationSyntax !== undefined) {
+                if (parsedDeclarationSyntax === null) {
+                    throw new Error(`Macro "${invocation.nameText}" does not have a declaration argument.`);
+                }
+                return parsedDeclarationSyntax;
+            }
+            const declarationSpan = getDeclarationSpan(invocation);
+            if (!declarationSpan) {
+                parsedDeclarationSyntax = null;
+                throw new Error(`Macro "${invocation.nameText}" does not have a declaration argument.`);
+            }
+            parsedDeclarationSyntax = createDeclSyntaxFromText(invocation.span.fileName, declarationSpan, sliceSpan(originalText, declarationSpan));
+            return parsedDeclarationSyntax;
+        };
+        const parseInvocationSyntaxForContext = () => {
+            if (parsedInvocationSyntax) {
+                return parsedInvocationSyntax;
+            }
+            parsedInvocationSyntax = createInvocationSyntax({
+                args: invocationView.args.map((_, index) => parseExprArgForContext(index)),
+                block: getBlockSpan(invocation) ? parseBlockSyntaxForContext() : null,
+                declaration: getDeclarationSpan(invocation) ? parseDeclarationSyntaxForContext() : null,
+                form: invocationView.form,
+                hasBlock: invocationView.hasBlock,
+                name: invocation.nameText,
+                span: invocation.span,
+                text: sliceSpan(originalText, invocation.span),
+            });
+            return parsedInvocationSyntax;
+        };
+        return {
+            build,
+            fresh,
+            host: createUnsupportedHostAccess('This macro requires compile-time host access, but only syntax-only context was available.'),
+            invocation: invocationView,
+            kind: invocation.rewriteKind,
+            name: invocation.nameText,
+            output,
+            quote,
+            runtime: runtimeTracker.access,
+            syntax: {
+                annotations(node) {
+                    return attachedAnnotationsForNode(node);
+                },
+                arg(index) {
+                    return parseExprArgForContext(index);
+                },
+                args() {
+                    return invocationView.args.map((_, index) => parseExprArgForContext(index));
+                },
+                block() {
+                    return parseBlockSyntaxForContext();
+                },
+                declaration() {
+                    return parseDeclarationSyntaxForContext();
+                },
+                primaryExpr() {
+                    const exprSpan = getPrimaryExprSpan(invocation);
+                    if (!exprSpan) {
+                        throw new Error(`Macro "${invocation.nameText}" does not have a primary expression argument.`);
+                    }
+                    return parseExprArgForContext(0);
+                },
+                root() {
+                    return parseInvocationSyntaxForContext();
+                },
+                template(index) {
+                    return parseTemplateArgForContext(index);
+                },
+            },
+            blockSpan() {
+                return getBlockSpan(invocation) ?? null;
+            },
+            declarationSpan() {
+                return getDeclarationSpan(invocation) ?? null;
+            },
+            error(message, _node) {
+                throw new Error(message);
+            },
+            hasBlock() {
+                return invocationView.hasBlock;
+            },
+            invocationSpan() {
+                return invocation.span;
+            },
+            location() {
+                const start = getLineAndColumn(originalText, invocation.span.start);
+                return {
+                    column: start.column,
+                    filePath: invocation.span.fileName,
+                    line: start.line,
+                };
+            },
+            parsedSyntax() {
+                return parseInvocationSyntaxForContext();
+            },
+            runtimeImports() {
+                return runtimeTracker.snapshot();
+            },
+            sourceText() {
+                return sliceSpan(originalText, invocation.span);
+            },
+        };
+    })();
+    const unsupported = (capability) => {
+        throw new Error(`Macro "${invocation.nameText}" cannot use ${capability} in syntax-only formatting contexts.`);
+    };
+    return {
+        ...base,
+        controlFlow: {
+            deferCleanup() {
+                return unsupported('controlFlow.deferCleanup');
+            },
+            freshBinding() {
+                return unsupported('controlFlow.freshBinding');
+            },
+            placement() {
+                return unsupported('controlFlow.placement');
+            },
+            rewriteWithValue() {
+                return unsupported('controlFlow.rewriteWithValue');
+            },
+        },
+        reflect: {
+            declarationShape() {
+                return unsupported('reflect.declarationShape');
+            },
+            typeShape() {
+                return unsupported('reflect.typeShape');
+            },
+        },
+        semantics: {
+            argExpanded() {
+                return unsupported('semantics.argExpanded');
+            },
+            argType() {
+                return unsupported('semantics.argType');
+            },
+            awaitedType() {
+                return unsupported('semantics.awaitedType');
+            },
+            classDeclarationOfType() {
+                return unsupported('semantics.classDeclarationOfType');
+            },
+            classifyCanonicalFailureType() {
+                return unsupported('semantics.classifyCanonicalFailureType');
+            },
+            classifyCanonicalResultCarrierType() {
+                return unsupported('semantics.classifyCanonicalResultCarrierType');
+            },
+            classifyCanonicalResultType() {
+                return unsupported('semantics.classifyCanonicalResultType');
+            },
+            classifyTryCarrierType() {
+                return unsupported('semantics.classifyTryCarrierType');
+            },
+            exprType() {
+                return unsupported('semantics.exprType');
+            },
+            enclosingFunction() {
+                return unsupported('semantics.enclosingFunction');
+            },
+            enclosingFunctionCanonicalResult() {
+                return unsupported('semantics.enclosingFunctionCanonicalResult');
+            },
+            finiteCases() {
+                return unsupported('semantics.finiteCases');
+            },
+            isAssignable() {
+                return unsupported('semantics.isAssignable');
+            },
+            localDeclarationHasAnnotation() {
+                return unsupported('semantics.localDeclarationHasAnnotation');
+            },
+            nullType() {
+                return unsupported('semantics.nullType');
+            },
+            parameterType() {
+                return unsupported('semantics.parameterType');
+            },
+            primaryExprEnclosingFunction() {
+                return unsupported('semantics.primaryExprEnclosingFunction');
+            },
+            primaryExprEnclosingFunctionCanonicalResult() {
+                return unsupported('semantics.primaryExprEnclosingFunctionCanonicalResult');
+            },
+            primaryExprExpanded() {
+                return unsupported('semantics.primaryExprExpanded');
+            },
+            primaryExprPrelude() {
+                return unsupported('semantics.primaryExprPrelude');
+            },
+            primaryExprCanonicalResultCarrier() {
+                return unsupported('semantics.primaryExprCanonicalResultCarrier');
+            },
+            primaryExprCanonicalResult() {
+                return unsupported('semantics.primaryExprCanonicalResult');
+            },
+            primaryExprContainsMacroInvocations() {
+                return unsupported('semantics.primaryExprContainsMacroInvocations');
+            },
+            primaryExprTryCarrier() {
+                return unsupported('semantics.primaryExprTryCarrier');
+            },
+            primaryExprType() {
+                return unsupported('semantics.primaryExprType');
+            },
+            readSet() {
+                return unsupported('semantics.readSet');
+            },
+            undefinedType() {
+                return unsupported('semantics.undefinedType');
+            },
+            valueBindingCallableInScope() {
+                return unsupported('semantics.valueBindingCallableInScope');
+            },
+            valueBindingInScope() {
+                return unsupported('semantics.valueBindingInScope');
+            },
+            writeSet() {
+                return unsupported('semantics.writeSet');
+            },
+        },
+    };
+}