@soundscript/soundscript 0.1.13 → 0.1.15

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

@@ -0,0 +1,919 @@
+import ts from 'typescript';
+import { collectResolvedMacroPlaceholders } from './macro_resolver.js';
+export const MACRO_EXPANSION_START_MARKER_PREFIX = '__SS_MACRO_EXPANSION_START_';
+export const MACRO_EXPANSION_END_MARKER_PREFIX = '__SS_MACRO_EXPANSION_END_';
+export function defineMacroModule(module) {
+    return module;
+}
+export function createMacroRegistry(entries) {
+    return new Map(Object.entries(entries));
+}
+export function buildMacroRegistryFromModules(modules) {
+    const registry = new Map();
+    for (const module of modules) {
+        for (const [name, expander] of Object.entries(module.expanders)) {
+            if (registry.has(name)) {
+                throw new Error(`Duplicate macro expander registration for "${name}" from module "${module.moduleName}".`);
+            }
+            registry.set(name, expander);
+        }
+    }
+    return registry;
+}
+export function buildAdvancedMacroRegistryFromModules(modules) {
+    const registry = new Map();
+    for (const module of modules) {
+        for (const [name, expander] of Object.entries(module.advancedExpanders ?? {})) {
+            if (registry.has(name)) {
+                throw new Error(`Duplicate advanced macro expander registration for "${name}" from module "${module.moduleName}".`);
+            }
+            registry.set(name, expander);
+        }
+    }
+    return registry;
+}
+function asExpansionMap(collected) {
+    return new Map(collected.map((entry) => [entry.resolved.placeholder.id, entry.resolved]));
+}
+function isMacroHelperDeclaration(node) {
+    return ts.isFunctionDeclaration(node) &&
+        !!node.modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.DeclareKeyword) &&
+        !!node.name &&
+        (node.name.text === '__sts_macro_expr' || node.name.text === '__sts_macro_stmt');
+}
+function stripMacroHelperDeclarations(sourceFile) {
+    return ts.factory.updateSourceFile(sourceFile, sourceFile.statements.filter((statement) => !isMacroHelperDeclaration(statement)));
+}
+function injectRuntimeImports(sourceFile, requests) {
+    if (requests.length === 0) {
+        return sourceFile;
+    }
+    const existingKeys = new Set();
+    for (const statement of sourceFile.statements) {
+        if (!ts.isImportDeclaration(statement) || !statement.importClause ||
+            !ts.isStringLiteral(statement.moduleSpecifier)) {
+            continue;
+        }
+        const specifier = statement.moduleSpecifier.text;
+        if (statement.importClause.name) {
+            existingKeys.add(`default\u0000${specifier}\u0000\u0000${statement.importClause.name.text}`);
+        }
+        if (statement.importClause.namedBindings) {
+            if (ts.isNamespaceImport(statement.importClause.namedBindings)) {
+                existingKeys.add(`namespace\u0000${specifier}\u0000\u0000${statement.importClause.namedBindings.name.text}`);
+            }
+            else {
+                for (const element of statement.importClause.namedBindings.elements) {
+                    existingKeys.add(`named\u0000${specifier}\u0000${element.propertyName?.text ?? element.name.text}\u0000${element.name.text}`);
+                }
+            }
+        }
+    }
+    const grouped = new Map();
+    for (const request of requests) {
+        const key = `${request.kind}\u0000${request.specifier}\u0000${request.exportName ?? ''}\u0000${request.localName}`;
+        if (existingKeys.has(key)) {
+            continue;
+        }
+        existingKeys.add(key);
+        const group = grouped.get(request.specifier) ?? {
+            namedImports: new Map(),
+        };
+        if (request.kind === 'default') {
+            group.defaultImport ?? (group.defaultImport = request.localName);
+        }
+        else if (request.kind === 'namespace') {
+            group.namespaceImport ?? (group.namespaceImport = request.localName);
+        }
+        else {
+            group.namedImports.set(request.exportName, request.localName);
+        }
+        grouped.set(request.specifier, group);
+    }
+    if (grouped.size === 0) {
+        return sourceFile;
+    }
+    const newImports = [];
+    for (const [specifier, group] of grouped.entries()) {
+        if (group.namespaceImport) {
+            newImports.push(ts.factory.createImportDeclaration(undefined, ts.factory.createImportClause(false, group.defaultImport ? ts.factory.createIdentifier(group.defaultImport) : undefined, ts.factory.createNamespaceImport(ts.factory.createIdentifier(group.namespaceImport))), ts.factory.createStringLiteral(specifier), undefined));
+            if (group.namedImports.size === 0) {
+                continue;
+            }
+        }
+        if (group.defaultImport || group.namedImports.size > 0) {
+            newImports.push(ts.factory.createImportDeclaration(undefined, ts.factory.createImportClause(false, group.defaultImport ? ts.factory.createIdentifier(group.defaultImport) : undefined, group.namedImports.size > 0
+                ? ts.factory.createNamedImports([...group.namedImports.entries()]
+                    .sort((left, right) => left[0].localeCompare(right[0]))
+                    .map(([exportName, localName]) => exportName === localName
+                    ? ts.factory.createImportSpecifier(false, undefined, ts.factory.createIdentifier(localName))
+                    : ts.factory.createImportSpecifier(false, ts.factory.createIdentifier(exportName), ts.factory.createIdentifier(localName))))
+                : undefined), ts.factory.createStringLiteral(specifier), undefined));
+        }
+    }
+    const insertionIndex = sourceFile.statements.findIndex((statement) => !ts.isImportDeclaration(statement));
+    const before = insertionIndex < 0
+        ? [...sourceFile.statements]
+        : sourceFile.statements.slice(0, insertionIndex);
+    const after = insertionIndex < 0 ? [] : sourceFile.statements.slice(insertionIndex);
+    return ts.factory.updateSourceFile(sourceFile, [
+        ...before,
+        ...newImports,
+        ...after,
+    ]);
+}
+function addExpansionStartMarker(node, id) {
+    ts.addSyntheticLeadingComment(node, ts.SyntaxKind.MultiLineCommentTrivia, `${MACRO_EXPANSION_START_MARKER_PREFIX}${id}__`, false);
+    return node;
+}
+function addExpansionEndMarker(node, id) {
+    ts.addSyntheticTrailingComment(node, ts.SyntaxKind.MultiLineCommentTrivia, `${MACRO_EXPANSION_END_MARKER_PREFIX}${id}__`, false);
+    return node;
+}
+function expandAdvancedMacroPlaceholdersInSourceFile(_preparedProgram, sourceFile, collected, registry, rewriteRegistry = new Map(), siteKindsBySpecifier = new Map(), annotateExpansions = false) {
+    if (registry.size === 0) {
+        return sourceFile;
+    }
+    const advancedSites = collected.filter((entry) => entry.sourceFile.fileName === sourceFile.fileName &&
+        registry.has(entry.resolved.placeholder.invocation.nameText));
+    if (advancedSites.length === 0) {
+        return sourceFile;
+    }
+    const expansions = new Map();
+    const runtimeImports = [];
+    const nestedRegistries = {
+        advanced: registry,
+        rewrite: rewriteRegistry,
+        siteKindsBySpecifier,
+    };
+    for (const site of advancedSites) {
+        const expander = registry.get(site.resolved.placeholder.invocation.nameText);
+        if (!expander) {
+            continue;
+        }
+        const expansion = expander(site.resolved, nestedRegistries);
+        if (expansion) {
+            expansions.set(site.resolved.placeholder.id, expansion);
+            runtimeImports.push(...(expansion.runtimeImports ?? []));
+        }
+    }
+    const transformer = (context) => {
+        let tempCounter = 0;
+        const lookupExpansion = (callExpression) => {
+            if (!ts.isIdentifier(callExpression.expression) ||
+                callExpression.expression.text !== '__sts_macro_expr' ||
+                callExpression.arguments.length !== 1) {
+                return undefined;
+            }
+            const [firstArgument] = callExpression.arguments;
+            if (!ts.isNumericLiteral(firstArgument)) {
+                return undefined;
+            }
+            const id = Number(firstArgument.text);
+            const expansion = expansions.get(id);
+            return expansion ? { expansion, id } : undefined;
+        };
+        function freshTempName(prefix = '__sts_expr') {
+            tempCounter += 1;
+            return `${prefix}_${tempCounter}`;
+        }
+        function cloneStatement(statement) {
+            return ts.factory
+                .cloneNode(statement);
+        }
+        function visitRequiredNode(node, description) {
+            const visited = ts.visitNode(node, visitTree);
+            if (!visited) {
+                throw new Error(`Expected transformer to preserve ${description}.`);
+            }
+            return visited;
+        }
+        function rewriteCurrentLoopContinues(statement, continueLabel, currentLoopLabels) {
+            const continueTarget = ts.factory.createIdentifier(continueLabel);
+            const visit = (node) => {
+                if (ts.isFunctionLike(node)) {
+                    return node;
+                }
+                if (node !== statement && ts.isIterationStatement(node, false)) {
+                    return node;
+                }
+                if (ts.isContinueStatement(node) &&
+                    (!node.label || currentLoopLabels.has(node.label.text))) {
+                    return ts.factory.createBreakStatement(continueTarget);
+                }
+                return ts.visitEachChild(node, visit, context);
+            };
+            return ts.visitNode(statement, visit);
+        }
+        function createVariableStatement(declarationKind, name, type, initializer) {
+            return ts.factory.createVariableStatement(undefined, ts.factory.createVariableDeclarationList([ts.factory.createVariableDeclaration(name, undefined, type, initializer)], declarationKind));
+        }
+        function createBlockStatement(statements) {
+            return statements.length === 1
+                ? statements[0]
+                : ts.factory.createBlock([...statements], true);
+        }
+        function createLabeledBodyStatement(labelName, statement) {
+            const bodyBlock = ts.isBlock(statement)
+                ? statement
+                : ts.factory.createBlock([statement], true);
+            return ts.factory.createLabeledStatement(ts.factory.createIdentifier(labelName), bodyBlock);
+        }
+        function createAssignmentStatement(name, expression) {
+            return ts.factory.createExpressionStatement(ts.factory.createBinaryExpression(ts.factory.createIdentifier(name), ts.factory.createToken(ts.SyntaxKind.EqualsToken), expression));
+        }
+        function collectLeadingLabels(statement) {
+            const labels = [];
+            let current = statement;
+            while (ts.isLabeledStatement(current)) {
+                labels.push(current.label.text);
+                current = current.statement;
+            }
+            return { labels, statement: current };
+        }
+        function reapplyLabels(labels, statements) {
+            if (labels.length === 0 || statements.length === 0) {
+                return statements;
+            }
+            const [last, ...restReversed] = [...statements].reverse();
+            const labeledLast = labels.reduceRight((current, label) => ts.factory.createLabeledStatement(ts.factory.createIdentifier(label), current), last);
+            return [...restReversed.reverse(), labeledLast];
+        }
+        function createIsNullishExpression(expression) {
+            return ts.factory.createBinaryExpression(ts.factory.createBinaryExpression(expression, ts.factory.createToken(ts.SyntaxKind.EqualsEqualsEqualsToken), ts.factory.createNull()), ts.factory.createToken(ts.SyntaxKind.BarBarToken), ts.factory.createBinaryExpression(expression, ts.factory.createToken(ts.SyntaxKind.EqualsEqualsEqualsToken), ts.factory.createIdentifier('undefined')));
+        }
+        function isOptionalCallExpression(node) {
+            return !!node.questionDotToken ||
+                (ts.isPropertyAccessExpression(node.expression) && !!node.expression.questionDotToken) ||
+                (ts.isElementAccessExpression(node.expression) && !!node.expression.questionDotToken);
+        }
+        function rewriteOptionalElementAccessExpression(node) {
+            if (!node.questionDotToken) {
+                return null;
+            }
+            const rewrittenBase = rewriteExpression(node.expression);
+            const rewrittenIndex = rewriteExpression(node.argumentExpression);
+            if (rewrittenBase.preludes.length === 0 && rewrittenIndex.preludes.length === 0) {
+                return null;
+            }
+            const baseTempName = freshTempName('__sts_chain');
+            const resultTempName = freshTempName('__sts_expr');
+            const baseIdentifier = () => ts.factory.createIdentifier(baseTempName);
+            return {
+                expression: ts.factory.createIdentifier(resultTempName),
+                preludes: [
+                    ...rewrittenBase.preludes,
+                    createVariableStatement(ts.NodeFlags.Const, baseTempName, undefined, rewrittenBase.expression),
+                    createVariableStatement(ts.NodeFlags.Let, resultTempName, undefined),
+                    ts.factory.createIfStatement(createIsNullishExpression(baseIdentifier()), createBlockStatement([
+                        createAssignmentStatement(resultTempName, ts.factory.createIdentifier('undefined')),
+                    ]), createBlockStatement([
+                        ...rewrittenIndex.preludes.map(cloneStatement),
+                        createAssignmentStatement(resultTempName, ts.factory.createElementAccessExpression(baseIdentifier(), rewrittenIndex.expression)),
+                    ])),
+                ],
+            };
+        }
+        function rewriteOptionalCallExpression(node) {
+            if (!isOptionalCallExpression(node)) {
+                return null;
+            }
+            let baseExpression;
+            let propertyName;
+            let elementExpression;
+            if (node.questionDotToken) {
+                baseExpression = node.expression;
+            }
+            else if (ts.isPropertyAccessExpression(node.expression) && node.expression.questionDotToken) {
+                baseExpression = node.expression.expression;
+                propertyName = node.expression.name;
+            }
+            else if (ts.isElementAccessExpression(node.expression) && node.expression.questionDotToken) {
+                baseExpression = node.expression.expression;
+                elementExpression = node.expression.argumentExpression;
+            }
+            else {
+                return null;
+            }
+            const rewrittenBase = rewriteExpression(baseExpression);
+            const rewrittenElement = elementExpression ? rewriteExpression(elementExpression) : null;
+            const rewrittenArguments = node.arguments.map((argument) => rewriteExpression(argument));
+            const needsGuardedRewrite = rewrittenBase.preludes.length > 0 ||
+                (rewrittenElement?.preludes.length ?? 0) > 0 ||
+                rewrittenArguments.some((argument) => argument.preludes.length > 0);
+            if (!needsGuardedRewrite) {
+                return null;
+            }
+            const baseTempName = freshTempName('__sts_chain');
+            const resultTempName = freshTempName('__sts_expr');
+            const baseIdentifier = () => ts.factory.createIdentifier(baseTempName);
+            let callee;
+            if (propertyName) {
+                callee = ts.factory.createPropertyAccessExpression(baseIdentifier(), propertyName);
+            }
+            else if (rewrittenElement) {
+                callee = ts.factory.createElementAccessExpression(baseIdentifier(), rewrittenElement.expression);
+            }
+            else {
+                callee = baseIdentifier();
+            }
+            const guardedStatements = [];
+            if (rewrittenElement) {
+                guardedStatements.push(...rewrittenElement.preludes.map(cloneStatement));
+            }
+            for (const rewrittenArgument of rewrittenArguments) {
+                guardedStatements.push(...rewrittenArgument.preludes.map(cloneStatement));
+            }
+            guardedStatements.push(createAssignmentStatement(resultTempName, ts.factory.createCallExpression(callee, node.typeArguments, rewrittenArguments.map((argument) => argument.expression))));
+            return {
+                expression: ts.factory.createIdentifier(resultTempName),
+                preludes: [
+                    ...rewrittenBase.preludes,
+                    createVariableStatement(ts.NodeFlags.Const, baseTempName, undefined, rewrittenBase.expression),
+                    createVariableStatement(ts.NodeFlags.Let, resultTempName, undefined),
+                    ts.factory.createIfStatement(createIsNullishExpression(baseIdentifier()), createBlockStatement([
+                        createAssignmentStatement(resultTempName, ts.factory.createIdentifier('undefined')),
+                    ]), createBlockStatement(guardedStatements)),
+                ],
+            };
+        }
+        function isShortCircuitOperator(kind) {
+            return kind === ts.SyntaxKind.AmpersandAmpersandToken ||
+                kind === ts.SyntaxKind.BarBarToken ||
+                kind === ts.SyntaxKind.QuestionQuestionToken;
+        }
+        function rewriteShortCircuitBinaryExpression(node) {
+            if (!isShortCircuitOperator(node.operatorToken.kind)) {
+                return null;
+            }
+            const left = rewriteExpression(node.left);
+            const right = rewriteExpression(node.right);
+            if (left.preludes.length === 0 && right.preludes.length === 0) {
+                return null;
+            }
+            const leftTempName = freshTempName('__sts_left');
+            const resultTempName = freshTempName('__sts_expr');
+            const leftIdentifier = () => ts.factory.createIdentifier(leftTempName);
+            let thenStatements;
+            let elseStatements;
+            switch (node.operatorToken.kind) {
+                case ts.SyntaxKind.AmpersandAmpersandToken:
+                    thenStatements = [
+                        ...right.preludes.map(cloneStatement),
+                        createAssignmentStatement(resultTempName, right.expression),
+                    ];
+                    elseStatements = [
+                        createAssignmentStatement(resultTempName, leftIdentifier()),
+                    ];
+                    break;
+                case ts.SyntaxKind.BarBarToken:
+                    thenStatements = [
+                        createAssignmentStatement(resultTempName, leftIdentifier()),
+                    ];
+                    elseStatements = [
+                        ...right.preludes.map(cloneStatement),
+                        createAssignmentStatement(resultTempName, right.expression),
+                    ];
+                    break;
+                default:
+                    thenStatements = [
+                        createAssignmentStatement(resultTempName, leftIdentifier()),
+                    ];
+                    elseStatements = [
+                        ...right.preludes.map(cloneStatement),
+                        createAssignmentStatement(resultTempName, right.expression),
+                    ];
+                    break;
+            }
+            const condition = node.operatorToken.kind === ts.SyntaxKind.QuestionQuestionToken
+                ? ts.factory.createBinaryExpression(ts.factory.createBinaryExpression(leftIdentifier(), ts.factory.createToken(ts.SyntaxKind.ExclamationEqualsEqualsToken), ts.factory.createNull()), ts.factory.createToken(ts.SyntaxKind.AmpersandAmpersandToken), ts.factory.createBinaryExpression(leftIdentifier(), ts.factory.createToken(ts.SyntaxKind.ExclamationEqualsEqualsToken), ts.factory.createIdentifier('undefined')))
+                : leftIdentifier();
+            return {
+                expression: ts.factory.createIdentifier(resultTempName),
+                preludes: [
+                    ...left.preludes,
+                    createVariableStatement(ts.NodeFlags.Const, leftTempName, undefined, left.expression),
+                    createVariableStatement(ts.NodeFlags.Let, resultTempName, undefined),
+                    ts.factory.createIfStatement(condition, createBlockStatement(thenStatements), createBlockStatement(elseStatements)),
+                ],
+            };
+        }
+        function rewriteExpression(expression) {
+            const preludes = [];
+            const visitExpression = (node) => {
+                if (ts.isCallExpression(node)) {
+                    const match = lookupExpansion(node);
+                    if (match?.expansion.kind === 'statement_region_rewrite') {
+                        const preludeStatements = match.expansion.preludeStatements.map((statement) => visitRequiredNode(statement, 'advanced prelude statement'));
+                        if (annotateExpansions && preludeStatements.length > 0) {
+                            addExpansionStartMarker(preludeStatements[0], match.id);
+                        }
+                        preludes.push(...preludeStatements);
+                        const replacementExpr = match.expansion.replacementExpr;
+                        const visitedReplacementExpr = visitRequiredNode(replacementExpr, 'advanced replacement expression');
+                        if (annotateExpansions) {
+                            if (preludeStatements.length === 0) {
+                                addExpansionStartMarker(visitedReplacementExpr, match.id);
+                            }
+                            addExpansionEndMarker(visitedReplacementExpr, match.id);
+                        }
+                        return visitedReplacementExpr;
+                    }
+                    const rewrittenOptionalCall = rewriteOptionalCallExpression(node);
+                    if (rewrittenOptionalCall) {
+                        preludes.push(...rewrittenOptionalCall.preludes);
+                        return rewrittenOptionalCall.expression;
+                    }
+                }
+                if (ts.isElementAccessExpression(node)) {
+                    const rewrittenOptionalElementAccess = rewriteOptionalElementAccessExpression(node);
+                    if (rewrittenOptionalElementAccess) {
+                        preludes.push(...rewrittenOptionalElementAccess.preludes);
+                        return rewrittenOptionalElementAccess.expression;
+                    }
+                }
+                if (ts.isBinaryExpression(node)) {
+                    const rewrittenShortCircuit = rewriteShortCircuitBinaryExpression(node);
+                    if (rewrittenShortCircuit) {
+                        preludes.push(...rewrittenShortCircuit.preludes);
+                        return rewrittenShortCircuit.expression;
+                    }
+                }
+                if (ts.isConditionalExpression(node)) {
+                    const condition = rewriteExpression(node.condition);
+                    const whenTrue = rewriteExpression(node.whenTrue);
+                    const whenFalse = rewriteExpression(node.whenFalse);
+                    const tempName = freshTempName('__sts_expr');
+                    preludes.push(...condition.preludes, createVariableStatement(ts.NodeFlags.Let, tempName, undefined), ts.factory.createIfStatement(condition.expression, createBlockStatement([
+                        ...whenTrue.preludes,
+                        createAssignmentStatement(tempName, whenTrue.expression),
+                    ]), createBlockStatement([
+                        ...whenFalse.preludes,
+                        createAssignmentStatement(tempName, whenFalse.expression),
+                    ])));
+                    return ts.factory.createIdentifier(tempName);
+                }
+                if (ts.isFunctionExpression(node)) {
+                    return ts.factory.updateFunctionExpression(node, node.modifiers, node.asteriskToken, node.name, node.typeParameters, node.parameters, node.type, ts.visitNode(node.body, visitTree));
+                }
+                if (ts.isArrowFunction(node)) {
+                    if (!ts.isBlock(node.body)) {
+                        const rewrittenBody = rewriteExpression(node.body);
+                        if (rewrittenBody.preludes.length > 0) {
+                            return ts.factory.updateArrowFunction(node, node.modifiers, node.typeParameters, node.parameters, node.type, node.equalsGreaterThanToken, ts.factory.createBlock([
+                                ...rewrittenBody.preludes,
+                                ts.factory.createReturnStatement(rewrittenBody.expression),
+                            ], true));
+                        }
+                    }
+                    return ts.factory.updateArrowFunction(node, node.modifiers, node.typeParameters, node.parameters, node.type, node.equalsGreaterThanToken, ts.isBlock(node.body) ? ts.visitNode(node.body, visitTree) : node.body);
+                }
+                if (ts.isClassExpression(node)) {
+                    return ts.visitEachChild(node, visitTree, context);
+                }
+                return ts.visitEachChild(node, visitExpression, context);
+            };
+            return {
+                expression: ts.visitNode(expression, visitExpression),
+                preludes,
+            };
+        }
+        function rewriteLogicalExpressionForStatement(expression) {
+            if (!ts.isBinaryExpression(expression)) {
+                return null;
+            }
+            return rewriteShortCircuitBinaryExpression(expression);
+        }
+        function rewriteForInitializer(initializer) {
+            if (!initializer) {
+                return {
+                    initializer: undefined,
+                    preludes: [],
+                    leadingStatements: [],
+                };
+            }
+            if (ts.isVariableDeclarationList(initializer)) {
+                const declaration = initializer.declarations[0];
+                if (!declaration?.initializer) {
+                    const visited = visitRequiredNode(initializer, 'for initializer');
+                    return {
+                        initializer: visited,
+                        preludes: [],
+                        leadingStatements: [ts.factory.createVariableStatement(undefined, visited)],
+                    };
+                }
+                const rewritten = rewriteLogicalExpressionForStatement(declaration.initializer) ??
+                    rewriteExpression(declaration.initializer);
+                const updatedDeclaration = ts.factory.updateVariableDeclaration(declaration, declaration.name, declaration.exclamationToken, declaration.type, rewritten.expression);
+                const updatedInitializer = ts.factory.updateVariableDeclarationList(initializer, [
+                    updatedDeclaration,
+                ]);
+                return {
+                    initializer: updatedInitializer,
+                    preludes: rewritten.preludes,
+                    leadingStatements: [
+                        ...rewritten.preludes,
+                        ts.factory.createVariableStatement(undefined, updatedInitializer),
+                    ],
+                };
+            }
+            const rewritten = rewriteLogicalExpressionForStatement(initializer) ??
+                rewriteExpression(initializer);
+            return {
+                initializer: rewritten.expression,
+                preludes: rewritten.preludes,
+                leadingStatements: [
+                    ...rewritten.preludes,
+                    ts.factory.createExpressionStatement(rewritten.expression),
+                ],
+            };
+        }
+        function rewriteStatement(statement) {
+            const labeled = collectLeadingLabels(statement);
+            if (labeled.labels.length > 0) {
+                return reapplyLabels(labeled.labels, rewriteStatementCore(labeled.statement, new Set(labeled.labels)));
+            }
+            return rewriteStatementCore(statement, new Set());
+        }
+        function rewriteStatementCore(statement, currentLoopLabels) {
+            if (ts.isVariableStatement(statement)) {
+                const declaration = statement.declarationList.declarations[0];
+                const initializer = declaration?.initializer;
+                if (!initializer) {
+                    return [visitRequiredNode(statement, 'variable statement without initializer')];
+                }
+                const rewritten = rewriteLogicalExpressionForStatement(initializer) ??
+                    rewriteExpression(initializer);
+                const updatedDeclaration = ts.factory.updateVariableDeclaration(declaration, declaration.name, declaration.exclamationToken, declaration.type, rewritten.expression);
+                return [
+                    ...rewritten.preludes,
+                    ts.factory.updateVariableStatement(statement, statement.modifiers, ts.factory.updateVariableDeclarationList(statement.declarationList, [
+                        updatedDeclaration,
+                    ])),
+                ];
+            }
+            if (ts.isExpressionStatement(statement)) {
+                const rewritten = rewriteLogicalExpressionForStatement(statement.expression) ??
+                    rewriteExpression(statement.expression);
+                return [
+                    ...rewritten.preludes,
+                    ts.factory.updateExpressionStatement(statement, rewritten.expression),
+                ];
+            }
+            if (ts.isReturnStatement(statement) && statement.expression) {
+                const rewritten = rewriteLogicalExpressionForStatement(statement.expression) ??
+                    rewriteExpression(statement.expression);
+                return [
+                    ...rewritten.preludes,
+                    ts.factory.updateReturnStatement(statement, rewritten.expression),
+                ];
+            }
+            if (ts.isThrowStatement(statement) && statement.expression) {
+                const rewritten = rewriteLogicalExpressionForStatement(statement.expression) ??
+                    rewriteExpression(statement.expression);
+                return [
+                    ...rewritten.preludes,
+                    ts.factory.updateThrowStatement(statement, rewritten.expression),
+                ];
+            }
+            if (ts.isIfStatement(statement)) {
+                const rewritten = rewriteLogicalExpressionForStatement(statement.expression) ??
+                    rewriteExpression(statement.expression);
+                return [
+                    ...rewritten.preludes,
+                    ts.factory.updateIfStatement(statement, rewritten.expression, visitRequiredNode(statement.thenStatement, 'if then statement'), statement.elseStatement
+                        ? visitRequiredNode(statement.elseStatement, 'if else statement')
+                        : undefined),
+                ];
+            }
+            if (ts.isWhileStatement(statement)) {
+                const rewritten = rewriteLogicalExpressionForStatement(statement.expression) ??
+                    rewriteExpression(statement.expression);
+                const visitedBody = visitRequiredNode(statement.statement, 'while body');
+                if (rewritten.preludes.length === 0) {
+                    return [
+                        ts.factory.updateWhileStatement(statement, rewritten.expression, visitedBody),
+                    ];
+                }
+                return [
+                    ts.factory.createWhileStatement(ts.factory.createTrue(), ts.factory.createBlock([
+                        ...rewritten.preludes,
+                        ts.factory.createIfStatement(ts.factory.createPrefixUnaryExpression(ts.SyntaxKind.ExclamationToken, rewritten.expression), ts.factory.createBlock([ts.factory.createBreakStatement()], true)),
+                        visitedBody,
+                    ], true)),
+                ];
+            }
+            if (ts.isSwitchStatement(statement)) {
+                const rewritten = rewriteLogicalExpressionForStatement(statement.expression) ??
+                    rewriteExpression(statement.expression);
+                return [
+                    ...rewritten.preludes,
+                    ts.factory.updateSwitchStatement(statement, rewritten.expression, visitRequiredNode(statement.caseBlock, 'switch case block')),
+                ];
+            }
+            if (ts.isForOfStatement(statement)) {
+                const rewritten = rewriteLogicalExpressionForStatement(statement.expression) ??
+                    rewriteExpression(statement.expression);
+                return [
+                    ...rewritten.preludes,
+                    ts.factory.updateForOfStatement(statement, statement.awaitModifier, visitRequiredNode(statement.initializer, 'for-of initializer'), rewritten.expression, visitRequiredNode(statement.statement, 'for-of body')),
+                ];
+            }
+            if (ts.isForInStatement(statement)) {
+                const rewritten = rewriteLogicalExpressionForStatement(statement.expression) ??
+                    rewriteExpression(statement.expression);
+                return [
+                    ...rewritten.preludes,
+                    ts.factory.updateForInStatement(statement, visitRequiredNode(statement.initializer, 'for-in initializer'), rewritten.expression, visitRequiredNode(statement.statement, 'for-in body')),
+                ];
+            }
+            if (ts.isDoStatement(statement)) {
+                const rewritten = rewriteLogicalExpressionForStatement(statement.expression) ??
+                    rewriteExpression(statement.expression);
+                const visitedBody = visitRequiredNode(statement.statement, 'do-while body');
+                if (rewritten.preludes.length === 0) {
+                    return [
+                        ts.factory.updateDoStatement(statement, visitedBody, rewritten.expression),
+                    ];
+                }
+                const continueLabel = freshTempName('__sts_continue');
+                return [
+                    ts.factory.createWhileStatement(ts.factory.createTrue(), ts.factory.createBlock([
+                        createLabeledBodyStatement(continueLabel, rewriteCurrentLoopContinues(visitedBody, continueLabel, currentLoopLabels)),
+                        ...rewritten.preludes,
+                        ts.factory.createIfStatement(ts.factory.createPrefixUnaryExpression(ts.SyntaxKind.ExclamationToken, rewritten.expression), ts.factory.createBlock([ts.factory.createBreakStatement()], true)),
+                    ], true)),
+                ];
+            }
+            if (ts.isForStatement(statement)) {
+                const initializer = rewriteForInitializer(statement.initializer);
+                const condition = statement.condition
+                    ? rewriteLogicalExpressionForStatement(statement.condition) ??
+                        rewriteExpression(statement.condition)
+                    : { expression: ts.factory.createTrue(), preludes: [] };
+                const incrementor = statement.incrementor
+                    ? rewriteLogicalExpressionForStatement(statement.incrementor) ??
+                        rewriteExpression(statement.incrementor)
+                    : null;
+                const visitedBody = visitRequiredNode(statement.statement, 'for body');
+                if (initializer.preludes.length === 0 &&
+                    condition.preludes.length === 0 &&
+                    (incrementor?.preludes.length ?? 0) === 0) {
+                    return [
+                        ts.factory.updateForStatement(statement, initializer.initializer, condition.expression, incrementor?.expression ??
+                            (statement.incrementor
+                                ? visitRequiredNode(statement.incrementor, 'for incrementor')
+                                : undefined), visitedBody),
+                    ];
+                }
+                const continueLabel = freshTempName('__sts_continue');
+                const loopStatements = [
+                    ...condition.preludes,
+                    ts.factory.createIfStatement(ts.factory.createPrefixUnaryExpression(ts.SyntaxKind.ExclamationToken, condition.expression), ts.factory.createBlock([ts.factory.createBreakStatement()], true)),
+                    createLabeledBodyStatement(continueLabel, rewriteCurrentLoopContinues(visitedBody, continueLabel, currentLoopLabels)),
+                ];
+                if (statement.incrementor) {
+                    if (incrementor) {
+                        loopStatements.push(...incrementor.preludes);
+                        loopStatements.push(ts.factory.createExpressionStatement(incrementor.expression));
+                    }
+                    else {
+                        loopStatements.push(ts.factory.createExpressionStatement(visitRequiredNode(statement.incrementor, 'for incrementor')));
+                    }
+                }
+                return [
+                    ...initializer.leadingStatements,
+                    ts.factory.createWhileStatement(ts.factory.createTrue(), ts.factory.createBlock(loopStatements, true)),
+                ];
+            }
+            return [visitRequiredNode(statement, `${ts.SyntaxKind[statement.kind]} statement`)];
+        }
+        function visitStatements(statements) {
+            const nextStatements = [];
+            for (const statement of statements) {
+                nextStatements.push(...rewriteStatement(statement));
+            }
+            return ts.factory.createNodeArray(nextStatements);
+        }
+        const visitTree = (node) => {
+            if (ts.isSourceFile(node)) {
+                return ts.factory.updateSourceFile(node, visitStatements(node.statements));
+            }
+            if (ts.isBlock(node)) {
+                return ts.factory.updateBlock(node, visitStatements(node.statements));
+            }
+            if (ts.isCaseClause(node)) {
+                return ts.factory.updateCaseClause(node, node.expression, visitStatements(node.statements));
+            }
+            if (ts.isDefaultClause(node)) {
+                return ts.factory.updateDefaultClause(node, visitStatements(node.statements));
+            }
+            if (ts.isModuleBlock(node)) {
+                return ts.factory.updateModuleBlock(node, visitStatements(node.statements));
+            }
+            return ts.visitEachChild(node, visitTree, context);
+        };
+        return (node) => ts.visitNode(node, visitTree);
+    };
+    const transformed = ts.transform(sourceFile, [transformer]);
+    const [expanded] = transformed.transformed;
+    transformed.dispose();
+    return injectRuntimeImports(stripMacroHelperDeclarations(expanded), runtimeImports);
+}
+export function expandMacroPlaceholdersInSourceFile(sourceFile, collected, expand, annotateExpansions = false) {
+    if (collected.length === 0) {
+        return stripMacroHelperDeclarations(sourceFile);
+    }
+    const expansions = asExpansionMap(collected.filter((entry) => entry.sourceFile.fileName === sourceFile.fileName));
+    if (expansions.size === 0) {
+        return stripMacroHelperDeclarations(sourceFile);
+    }
+    const runtimeImports = [];
+    const transformer = (context) => {
+        let tempCounter = 0;
+        const lookupResolved = (callExpression) => {
+            if (!ts.isIdentifier(callExpression.expression) ||
+                !(callExpression.expression.text === '__sts_macro_expr' ||
+                    callExpression.expression.text === '__sts_macro_stmt') ||
+                callExpression.arguments.length !== 1) {
+                return undefined;
+            }
+            const [firstArgument] = callExpression.arguments;
+            return ts.isNumericLiteral(firstArgument)
+                ? expansions.get(Number(firstArgument.text))
+                : undefined;
+        };
+        function freshTempName(prefix = '__sts_defer') {
+            tempCounter += 1;
+            return `${prefix}_${tempCounter}`;
+        }
+        function createScopeExitPushStatement(stackName, cleanupStatements) {
+            return ts.factory.createExpressionStatement(ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier(stackName), 'push'), undefined, [
+                ts.factory.createArrowFunction(undefined, undefined, [], undefined, ts.factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken), ts.factory.createBlock([...cleanupStatements], true)),
+            ]));
+        }
+        function createScopeExitDrainStatement(stackName, indexName) {
+            const stackIdentifier = ts.factory.createIdentifier(stackName);
+            const indexIdentifier = ts.factory.createIdentifier(indexName);
+            return ts.factory.createForStatement(ts.factory.createVariableDeclarationList([
+                ts.factory.createVariableDeclaration(indexIdentifier, undefined, undefined, ts.factory.createBinaryExpression(ts.factory.createPropertyAccessExpression(stackIdentifier, 'length'), ts.factory.createToken(ts.SyntaxKind.MinusToken), ts.factory.createNumericLiteral('1'))),
+            ], ts.NodeFlags.Let), ts.factory.createBinaryExpression(indexIdentifier, ts.factory.createToken(ts.SyntaxKind.GreaterThanEqualsToken), ts.factory.createNumericLiteral('0')), ts.factory.createPostfixUnaryExpression(indexIdentifier, ts.SyntaxKind.MinusMinusToken), ts.factory.createBlock([
+                ts.factory.createExpressionStatement(ts.factory.createCallExpression(ts.factory.createElementAccessExpression(stackIdentifier, indexIdentifier), undefined, [])),
+            ], true));
+        }
+        function expandStatementEntry(statement) {
+            if (ts.isExpressionStatement(statement) && ts.isCallExpression(statement.expression)) {
+                const resolved = lookupResolved(statement.expression);
+                if (resolved && resolved.placeholder.invocation.rewriteKind === 'stmt') {
+                    const expansion = expand(resolved);
+                    if (!expansion) {
+                        return {
+                            kind: 'stmt',
+                            nodes: [statement],
+                        };
+                    }
+                    if (expansion.kind === 'scope_exit') {
+                        runtimeImports.push(...(expansion.runtimeImports ?? []));
+                        return {
+                            cleanupStatements: expansion.cleanupStatements.map((node) => ts.visitNode(node, visitStatementOrExpression)),
+                            kind: 'scope_exit',
+                        };
+                    }
+                    if (expansion.kind !== 'stmt') {
+                        throw new Error('Statement macro placeholder must expand to statement nodes.');
+                    }
+                    runtimeImports.push(...(expansion.runtimeImports ?? []));
+                    const nodes = expansion.nodes.map((node) => ts.visitNode(node, visitStatementOrExpression));
+                    if (annotateExpansions && nodes.length > 0) {
+                        addExpansionStartMarker(nodes[0], resolved.placeholder.id);
+                        addExpansionEndMarker(nodes[nodes.length - 1], resolved.placeholder.id);
+                    }
+                    return {
+                        kind: 'stmt',
+                        nodes,
+                    };
+                }
+            }
+            return {
+                kind: 'stmt',
+                nodes: [ts.visitNode(statement, visitStatementOrExpression)],
+            };
+        }
+        function visitStatements(containerKind, statements) {
+            const transformedEntries = statements.map((statement) => expandStatementEntry(statement));
+            if (!transformedEntries.some((entry) => entry.kind === 'scope_exit')) {
+                const nextStatements = [];
+                for (const entry of transformedEntries) {
+                    if (entry.kind === 'stmt') {
+                        nextStatements.push(...entry.nodes);
+                    }
+                }
+                return ts.factory.createNodeArray(nextStatements);
+            }
+            if (containerKind === 'source_file') {
+                throw new Error('Defer can only be used inside block-scoped statement lists and cannot be used at module scope.');
+            }
+            const stackName = freshTempName('__sts_defer_stack');
+            const indexName = freshTempName('__sts_defer_index');
+            const bodyStatements = [];
+            for (const entry of transformedEntries) {
+                if (entry.kind === 'scope_exit') {
+                    bodyStatements.push(createScopeExitPushStatement(stackName, entry.cleanupStatements));
+                    continue;
+                }
+                bodyStatements.push(...entry.nodes);
+            }
+            const nextStatements = [
+                ts.factory.createVariableStatement(undefined, ts.factory.createVariableDeclarationList([ts.factory.createVariableDeclaration(stackName, undefined, undefined, ts.factory.createArrayLiteralExpression([], false))], ts.NodeFlags.Const)),
+                ts.factory.createTryStatement(ts.factory.createBlock(bodyStatements, true), undefined, ts.factory.createBlock([createScopeExitDrainStatement(stackName, indexName)], true)),
+            ];
+            return ts.factory.createNodeArray(nextStatements);
+        }
+        const visitStatementOrExpression = (node) => {
+            if (ts.isSourceFile(node)) {
+                return ts.factory.updateSourceFile(node, visitStatements('source_file', node.statements));
+            }
+            if (ts.isBlock(node)) {
+                return ts.factory.updateBlock(node, visitStatements('block', node.statements));
+            }
+            if (ts.isCaseClause(node)) {
+                return ts.factory.updateCaseClause(node, node.expression, visitStatements('case', node.statements));
+            }
+            if (ts.isDefaultClause(node)) {
+                return ts.factory.updateDefaultClause(node, visitStatements('default', node.statements));
+            }
+            if (ts.isModuleBlock(node)) {
+                return ts.factory.updateModuleBlock(node, visitStatements('module', node.statements));
+            }
+            if (ts.isCallExpression(node)) {
+                const resolved = lookupResolved(node);
+                if (resolved && resolved.placeholder.invocation.rewriteKind === 'expr') {
+                    const expansion = expand(resolved);
+                    if (!expansion) {
+                        return node;
+                    }
+                    if (expansion.kind !== 'expr') {
+                        throw new Error('Expression macro placeholder must expand to an expression node.');
+                    }
+                    runtimeImports.push(...(expansion.runtimeImports ?? []));
+                    const visitedNode = ts.visitNode(expansion.node, visitStatementOrExpression);
+                    if (annotateExpansions) {
+                        addExpansionStartMarker(visitedNode, resolved.placeholder.id);
+                        addExpansionEndMarker(visitedNode, resolved.placeholder.id);
+                    }
+                    return visitedNode;
+                }
+            }
+            return ts.visitEachChild(node, visitStatementOrExpression, context);
+        };
+        return (node) => ts.visitNode(node, visitStatementOrExpression);
+    };
+    const transformed = ts.transform(sourceFile, [transformer]);
+    const [expanded] = transformed.transformed;
+    const withoutHelpers = stripMacroHelperDeclarations(expanded);
+    transformed.dispose();
+    return injectRuntimeImports(withoutHelpers, runtimeImports);
+}
+export function expandMacroPlaceholdersWithRegistry(sourceFile, collected, registry, preserveMissingExpanders = false, annotateExpansions = false) {
+    return expandMacroPlaceholdersInSourceFile(sourceFile, collected, (resolved) => {
+        const expander = registry.get(resolved.placeholder.invocation.nameText);
+        if (!expander) {
+            if (preserveMissingExpanders) {
+                return undefined;
+            }
+            throw new Error(`No macro expander registered for "${resolved.placeholder.invocation.nameText}".`);
+        }
+        return expander(resolved);
+    }, annotateExpansions);
+}
+export function expandPreparedProgramWithRegistry(preparedProgram, registry, advancedRegistry = new Map()) {
+    const collected = collectResolvedMacroPlaceholders(preparedProgram);
+    const expandedFiles = new Map();
+    for (const sourceFile of preparedProgram.program.getSourceFiles()) {
+        if (sourceFile.isDeclarationFile) {
+            continue;
+        }
+        const withAdvancedExpanded = expandAdvancedMacroPlaceholdersInSourceFile(preparedProgram, sourceFile, collected, advancedRegistry, registry);
+        expandedFiles.set(sourceFile.fileName, expandMacroPlaceholdersWithRegistry(withAdvancedExpanded, collected, registry));
+    }
+    return expandedFiles;
+}
+export function expandPreparedProgramWithModules(preparedProgram, modules) {
+    return expandPreparedProgramWithRegistry(preparedProgram, buildMacroRegistryFromModules(modules), buildAdvancedMacroRegistryFromModules(modules));
+}
+export function expandPreparedProgramWithFileRegistries(preparedProgram, registriesByFile, preserveMissingExpanders = false, annotateExpansions = false) {
+    const collected = collectResolvedMacroPlaceholders(preparedProgram);
+    const expandedFiles = new Map();
+    for (const sourceFile of preparedProgram.program.getSourceFiles()) {
+        if (sourceFile.isDeclarationFile) {
+            continue;
+        }
+        const fileRegistries = registriesByFile.get(sourceFile.fileName);
+        const advancedRegistry = fileRegistries?.advancedRegistry ?? new Map();
+        const registry = fileRegistries?.registry ?? new Map();
+        const siteKindsBySpecifier = fileRegistries?.siteKindsBySpecifier ?? new Map();
+        const withAdvancedExpanded = expandAdvancedMacroPlaceholdersInSourceFile(preparedProgram, sourceFile, collected, advancedRegistry, registry, siteKindsBySpecifier, annotateExpansions);
+        expandedFiles.set(sourceFile.fileName, expandMacroPlaceholdersWithRegistry(withAdvancedExpanded, collected, registry, preserveMissingExpanders, annotateExpansions));
+    }
+    return expandedFiles;
+}