@soundscript/soundscript 0.1.12 → 0.1.15

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

@@ -0,0 +1,838 @@
+import ts from 'typescript';
+import { expandPreparedProgramWithFileRegistries } from './macro_expander.js';
+import { createPreparedProgram, mapProgramPositionToSource, mapSourcePositionToProgram, } from './project_frontend.js';
+import { rewriteMacroSource } from './macro_rewrite.js';
+import { createMacroSemantics } from './macro_semantics.js';
+const COMPLETION_PLACEHOLDER_IDENTIFIER = '__sts_completion_target';
+function isNestedMacroHoverTarget(value) {
+    return 'kind' in value;
+}
+function _getPrimaryExprSpan(invocation) {
+    if (getBlockSpan(invocation) || invocation.declarationSpan) {
+        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 getExprArgumentSpan(invocation, index) {
+    const argument = invocation.argumentSpans[index];
+    return argument?.kind === 'ExprArg' ? argument.span : undefined;
+}
+function _getExpressionArgumentSpan(invocation, expressionArgumentIndex) {
+    const expressionArguments = invocation.argumentSpans.filter((argument) => argument.kind === 'ExprArg');
+    return expressionArguments[expressionArgumentIndex]?.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 containsPosition(span, position) {
+    return position >= span.start && position < span.end;
+}
+function isIdentifierPart(character) {
+    return character !== undefined && /[\p{ID_Continue}_$\u200C\u200D]/u.test(character);
+}
+function neutralizeMacroInvocation(invocation) {
+    return invocation.rewriteKind === 'expr' ? 'undefined' : '{}';
+}
+function replaceRange(text, start, end, replacement) {
+    return text.slice(0, start) + replacement + text.slice(end);
+}
+function createStageTwoPreparedFile(preparedFile) {
+    if (!preparedFile.postRewriteStage) {
+        return null;
+    }
+    return {
+        diagnostics: preparedFile.diagnostics,
+        originalText: preparedFile.rewriteResult.rewrittenText,
+        rewriteResult: preparedFile.postRewriteStage,
+        rewrittenText: preparedFile.rewrittenText,
+    };
+}
+function mapProgramPositionToStageOne(preparedFile, position) {
+    const stageTwoPreparedFile = createStageTwoPreparedFile(preparedFile);
+    return stageTwoPreparedFile
+        ? mapProgramPositionToSource(stageTwoPreparedFile, position).position
+        : position;
+}
+function mapStageOnePositionToProgram(preparedFile, position) {
+    const stageTwoPreparedFile = createStageTwoPreparedFile(preparedFile);
+    return stageTwoPreparedFile
+        ? mapSourcePositionToProgram(stageTwoPreparedFile, position).position
+        : position;
+}
+function appendMappedText(output, mappings, text, sourceStart) {
+    if (text.length === 0) {
+        return output;
+    }
+    const generatedStart = output.length;
+    mappings.push({
+        generatedStart,
+        generatedEnd: generatedStart + text.length,
+        sourceStart,
+        sourceEnd: sourceStart + text.length,
+    });
+    return output + text;
+}
+function collectInvocationsInRegion(fileName, originalText, regionSpan) {
+    const rewriteResult = rewriteMacroSource(fileName, originalText, new Map(), getAlwaysAvailableBuiltinMacroSiteKinds());
+    if (rewriteResult.replacements.length === 0) {
+        return [];
+    }
+    return rewriteResult.replacements
+        .map((replacement) => rewriteResult.macrosById.get(replacement.id))
+        .filter((invocation) => invocation !== undefined &&
+        invocation.span.start >= regionSpan.start &&
+        invocation.span.start < regionSpan.end &&
+        invocation.span.end <= regionSpan.end)
+        .sort((left, right) => left.span.start - right.span.start || left.span.end - right.span.end);
+}
+function findContainingStatement(node) {
+    let current = node;
+    while (current && !ts.isSourceFile(current)) {
+        if (ts.isStatement(current)) {
+            let statement = current;
+            while (statement.parent && ts.isLabeledStatement(statement.parent)) {
+                statement = statement.parent;
+            }
+            return statement;
+        }
+        current = current.parent;
+    }
+    return undefined;
+}
+function isSentinelStatement(statement, name) {
+    return ts.isExpressionStatement(statement) &&
+        ts.isCallExpression(statement.expression) &&
+        ts.isIdentifier(statement.expression.expression) &&
+        statement.expression.expression.text === name &&
+        statement.expression.arguments.length === 0;
+}
+function findStatementRegionBetweenSentinels(node, beforeName, afterName) {
+    const statements = (() => {
+        if (ts.isSourceFile(node) || ts.isBlock(node) || ts.isModuleBlock(node)) {
+            return node.statements;
+        }
+        if (ts.isCaseClause(node) || ts.isDefaultClause(node)) {
+            return node.statements;
+        }
+        return null;
+    })();
+    if (statements) {
+        const beforeIndex = statements.findIndex((statement) => isSentinelStatement(statement, beforeName));
+        const afterIndex = statements.findIndex((statement) => isSentinelStatement(statement, afterName));
+        if (beforeIndex >= 0 && afterIndex > beforeIndex) {
+            return statements.slice(beforeIndex + 1, afterIndex);
+        }
+    }
+    return ts.forEachChild(node, (child) => findStatementRegionBetweenSentinels(child, beforeName, afterName)) ?? null;
+}
+function findCaptureCallInStatement(statement, captureName) {
+    let found;
+    function visit(node) {
+        if (ts.isCallExpression(node) &&
+            ts.isIdentifier(node.expression) &&
+            node.expression.text === captureName) {
+            found = node;
+            return;
+        }
+        ts.forEachChild(node, visit);
+    }
+    visit(statement);
+    return found;
+}
+function printNode(sourceFile, node, hint) {
+    return ts.createPrinter({ removeComments: false }).printNode(hint, node, sourceFile);
+}
+function collectSyntheticNames(statements) {
+    const names = new Set();
+    function collectBindingName(name) {
+        if (ts.isIdentifier(name) && name.text.startsWith('__sts_')) {
+            names.add(name.text);
+            return;
+        }
+        if (ts.isObjectBindingPattern(name) || ts.isArrayBindingPattern(name)) {
+            for (const element of name.elements) {
+                if (ts.isBindingElement(element)) {
+                    collectBindingName(element.name);
+                }
+            }
+        }
+    }
+    function visit(node) {
+        if (ts.isVariableDeclaration(node)) {
+            collectBindingName(node.name);
+        }
+        else if (ts.isLabeledStatement(node) && node.label.text.startsWith('__sts_')) {
+            names.add(node.label.text);
+        }
+        ts.forEachChild(node, visit);
+    }
+    for (const statement of statements) {
+        visit(statement);
+    }
+    return names;
+}
+function renameSyntheticNamesInNode(node, renameMap) {
+    if (renameMap.size === 0) {
+        return node;
+    }
+    const transformed = ts.transform(node, [
+        (context) => {
+            const visitor = (current) => {
+                if (ts.isIdentifier(current)) {
+                    const renamed = renameMap.get(current.text);
+                    if (renamed) {
+                        return ts.factory.createIdentifier(renamed);
+                    }
+                    return current;
+                }
+                if (ts.isLabeledStatement(current)) {
+                    const renamed = renameMap.get(current.label.text);
+                    if (renamed) {
+                        return ts.factory.updateLabeledStatement(current, ts.factory.createIdentifier(renamed), ts.visitNode(current.statement, visitor));
+                    }
+                }
+                if (ts.isBreakStatement(current) && current.label) {
+                    const renamed = renameMap.get(current.label.text);
+                    if (renamed) {
+                        return ts.factory.updateBreakStatement(current, ts.factory.createIdentifier(renamed));
+                    }
+                }
+                if (ts.isContinueStatement(current) && current.label) {
+                    const renamed = renameMap.get(current.label.text);
+                    if (renamed) {
+                        return ts.factory.updateContinueStatement(current, ts.factory.createIdentifier(renamed));
+                    }
+                }
+                return ts.visitEachChild(current, visitor, context);
+            };
+            return (root) => ts.visitNode(root, visitor);
+        },
+    ]);
+    try {
+        return transformed.transformed[0];
+    }
+    finally {
+        transformed.dispose();
+    }
+}
+function containsNestedAdvancedMacroCall(fileName, operandText, advancedRegistry) {
+    if (advancedRegistry.size === 0) {
+        return false;
+    }
+    const sourceFile = ts.createSourceFile(fileName, `const __sts_probe = ${operandText};`, ts.ScriptTarget.Latest, true, ts.ScriptKind.TSX);
+    let found = false;
+    const visit = (node) => {
+        if (ts.isCallExpression(node) &&
+            ts.isIdentifier(node.expression) &&
+            /^[A-Z]/u.test(node.expression.text) &&
+            advancedRegistry.has(node.expression.text)) {
+            found = true;
+            return;
+        }
+        ts.forEachChild(node, visit);
+    };
+    ts.forEachChild(sourceFile, visit);
+    return found;
+}
+function expandNestedOperandSource(preparedProgram, resolved, patchedText, nestedRegistries) {
+    const replacement = resolved.placeholder.replacement;
+    const rewrittenProgramFileName = preparedProgram.toProgramFileName(replacement.rewrittenSpan.fileName);
+    const nestedPreparedProgram = createPreparedProgram({
+        baseHost: preparedProgram.preparedHost.host,
+        fileOverrides: new Map([[replacement.rewrittenSpan.fileName, patchedText]]),
+        importedMacroSiteKindsBySpecifier: nestedRegistries.siteKindsBySpecifier ?? new Map(),
+        options: preparedProgram.options,
+        rootNames: preparedProgram.rootNames,
+    });
+    const expandedFiles = expandPreparedProgramWithFileRegistries(nestedPreparedProgram, new Map([[
+            rewrittenProgramFileName,
+            {
+                registry: nestedRegistries.rewrite,
+                advancedRegistry: nestedRegistries.advanced,
+            },
+        ]]));
+    const expandedSourceFile = expandedFiles.get(rewrittenProgramFileName);
+    if (!expandedSourceFile) {
+        return null;
+    }
+    const expandedText = printNode(expandedSourceFile, expandedSourceFile, ts.EmitHint.Unspecified);
+    const overrideHost = {
+        ...nestedPreparedProgram.preparedHost.host,
+        getSourceFile(fileName, languageVersion, onError, shouldCreateNewSourceFile) {
+            if (fileName === rewrittenProgramFileName) {
+                return ts.createSourceFile(fileName, expandedText, languageVersion, true);
+            }
+            return nestedPreparedProgram.preparedHost.host.getSourceFile(fileName, languageVersion, onError, shouldCreateNewSourceFile);
+        },
+        readFile(fileName) {
+            if (fileName === rewrittenProgramFileName) {
+                return expandedText;
+            }
+            return nestedPreparedProgram.preparedHost.host.readFile(fileName);
+        },
+    };
+    const finalProgram = ts.createProgram({
+        host: overrideHost,
+        options: nestedPreparedProgram.options,
+        rootNames: nestedPreparedProgram.rootNames.map((fileName) => nestedPreparedProgram.toProgramFileName(fileName)),
+    });
+    return finalProgram.getSourceFile(rewrittenProgramFileName) ?? null;
+}
+function materializeNestedOperandExpansionViaCapture(preparedProgram, resolved, operandText, nestedRegistries) {
+    const replacement = resolved.placeholder.replacement;
+    const preparedFile = resolved.placeholder.preparedFile;
+    const sourceFile = resolved.callExpression.getSourceFile();
+    const containingStatement = findContainingStatement(resolved.callExpression);
+    if (!containingStatement) {
+        return null;
+    }
+    const captureName = '__sts_nested_capture';
+    const beforeName = '__sts_nested_before';
+    const afterName = '__sts_nested_after';
+    const statementStart = mapProgramPositionToStageOne(preparedFile, containingStatement.getStart(sourceFile));
+    const statementEnd = mapProgramPositionToStageOne(preparedFile, containingStatement.getEnd());
+    const replacementStart = replacement.rewrittenSpan.start;
+    const replacementEnd = replacement.rewrittenSpan.end;
+    const statementText = preparedFile.rewriteResult.rewrittenText.slice(statementStart, statementEnd);
+    const patchedStatementText = replaceRange(statementText, replacementStart - statementStart, replacementEnd - statementStart, `${captureName}(${operandText})`);
+    const patchedText = [
+        preparedFile.rewriteResult.rewrittenText.slice(0, statementStart),
+        `${beforeName}();\n${patchedStatementText}\n${afterName}();`,
+        preparedFile.rewriteResult.rewrittenText.slice(statementEnd),
+    ].join('');
+    const finalSourceFile = expandNestedOperandSource(preparedProgram, resolved, patchedText, nestedRegistries);
+    if (!finalSourceFile) {
+        return null;
+    }
+    const statementRegion = findStatementRegionBetweenSentinels(finalSourceFile, beforeName, afterName);
+    if (!statementRegion || statementRegion.length === 0) {
+        return null;
+    }
+    const filteredRegion = statementRegion.filter((statement) => !isSentinelStatement(statement, beforeName) && !isSentinelStatement(statement, afterName));
+    if (filteredRegion.length === 0) {
+        return null;
+    }
+    const statementIndex = filteredRegion.findIndex((statement) => findCaptureCallInStatement(statement, captureName) !== undefined);
+    if (statementIndex < 0) {
+        return null;
+    }
+    const captureCall = findCaptureCallInStatement(filteredRegion[statementIndex], captureName);
+    if (!captureCall || captureCall.arguments.length !== 1) {
+        return null;
+    }
+    const syntheticNames = collectSyntheticNames(filteredRegion);
+    const renameMap = new Map();
+    for (const syntheticName of syntheticNames) {
+        renameMap.set(syntheticName, `${syntheticName}__nested_${resolved.placeholder.id}`);
+    }
+    const renamedPreludeStatements = filteredRegion
+        .slice(0, statementIndex)
+        .map((statement) => renameSyntheticNamesInNode(statement, renameMap));
+    const renamedExpression = renameSyntheticNamesInNode(captureCall.arguments[0], renameMap);
+    return {
+        expressionText: printNode(finalSourceFile, renamedExpression, ts.EmitHint.Expression),
+        preludeTexts: renamedPreludeStatements.map((statement) => printNode(finalSourceFile, statement, ts.EmitHint.Unspecified)),
+    };
+}
+function materializeNestedOperandExpansionViaTempBinding(preparedProgram, resolved, operandText, nestedRegistries) {
+    const preparedFile = resolved.placeholder.preparedFile;
+    const sourceFile = resolved.callExpression.getSourceFile();
+    const containingStatement = findContainingStatement(resolved.callExpression);
+    if (!containingStatement) {
+        return null;
+    }
+    const beforeName = '__sts_nested_before';
+    const afterName = '__sts_nested_after';
+    const resultName = '__sts_nested_result';
+    const statementStart = mapProgramPositionToStageOne(preparedFile, containingStatement.getStart(sourceFile));
+    const patchedText = [
+        preparedFile.rewriteResult.rewrittenText.slice(0, statementStart),
+        `${beforeName}();\nconst ${resultName} = ${operandText};\n${afterName}();\n`,
+        preparedFile.rewriteResult.rewrittenText.slice(statementStart),
+    ].join('');
+    const finalSourceFile = expandNestedOperandSource(preparedProgram, resolved, patchedText, nestedRegistries);
+    if (!finalSourceFile) {
+        return null;
+    }
+    const statementRegion = findStatementRegionBetweenSentinels(finalSourceFile, beforeName, afterName);
+    if (!statementRegion || statementRegion.length === 0) {
+        return null;
+    }
+    const filteredRegion = statementRegion.filter((statement) => !isSentinelStatement(statement, beforeName) && !isSentinelStatement(statement, afterName));
+    if (filteredRegion.length === 0) {
+        return null;
+    }
+    const syntheticNames = collectSyntheticNames(filteredRegion);
+    const renameMap = new Map();
+    for (const syntheticName of syntheticNames) {
+        renameMap.set(syntheticName, `${syntheticName}__nested_${resolved.placeholder.id}`);
+    }
+    const renamedPreludeStatements = filteredRegion.map((statement) => renameSyntheticNamesInNode(statement, renameMap));
+    const renamedResultName = renameMap.get(resultName) ?? resultName;
+    return {
+        expressionText: renamedResultName,
+        preludeTexts: renamedPreludeStatements.map((statement) => printNode(finalSourceFile, statement, ts.EmitHint.Unspecified)),
+    };
+}
+function materializeNestedOperandExpansion(preparedProgram, resolved, operandText, nestedRegistries) {
+    return containsNestedAdvancedMacroCall(resolved.placeholder.invocation.fileName, operandText, nestedRegistries.advanced)
+        ? materializeNestedOperandExpansionViaTempBinding(preparedProgram, resolved, operandText, nestedRegistries)
+        : materializeNestedOperandExpansionViaCapture(preparedProgram, resolved, operandText, nestedRegistries);
+}
+function findExpressionAtSpan(sourceFile, start, end) {
+    let found;
+    function visit(node) {
+        if (ts.isExpression(node) &&
+            node.getStart(sourceFile) === start &&
+            node.getEnd() === end) {
+            found = node;
+            return;
+        }
+        ts.forEachChild(node, visit);
+    }
+    visit(sourceFile);
+    return found;
+}
+function findDeepestNodeContainingPosition(node, position) {
+    if (position < node.getFullStart() || position >= node.getEnd()) {
+        return undefined;
+    }
+    const child = ts.forEachChild(node, (currentChild) => findDeepestNodeContainingPosition(currentChild, position));
+    return child ?? node;
+}
+function createPatchedMacroSource(preparedProgram, resolved, replacementText) {
+    const replacement = resolved.placeholder.replacement;
+    const preparedFile = resolved.placeholder.preparedFile;
+    const rewrittenFileName = preparedProgram.toProgramFileName(replacement.rewrittenSpan.fileName);
+    const programReplacementStart = mapStageOnePositionToProgram(preparedFile, replacement.rewrittenSpan.start);
+    const programReplacementEnd = mapStageOnePositionToProgram(preparedFile, replacement.rewrittenSpan.end);
+    const patchedText = replaceRange(preparedFile.rewrittenText, programReplacementStart, programReplacementEnd, replacementText);
+    const overrideHost = {
+        ...preparedProgram.preparedHost.host,
+        getSourceFile(fileName, languageVersion, onError, shouldCreateNewSourceFile) {
+            if (fileName === rewrittenFileName) {
+                return ts.createSourceFile(fileName, patchedText, languageVersion, true);
+            }
+            return preparedProgram.preparedHost.host.getSourceFile(fileName, languageVersion, onError, shouldCreateNewSourceFile);
+        },
+        readFile(fileName) {
+            if (fileName === rewrittenFileName) {
+                return patchedText;
+            }
+            return preparedProgram.preparedHost.host.readFile(fileName);
+        },
+    };
+    const patchedProgram = ts.createProgram({
+        host: overrideHost,
+        options: preparedProgram.options,
+        rootNames: preparedProgram.rootNames.map((fileName) => preparedProgram.toProgramFileName(fileName)),
+    });
+    const patchedSourceFile = patchedProgram.getSourceFile(rewrittenFileName);
+    if (!patchedSourceFile) {
+        return null;
+    }
+    return {
+        checker: patchedProgram.getTypeChecker(),
+        originalReplacementEnd: programReplacementEnd,
+        originalReplacementStart: programReplacementStart,
+        rewrittenStart: programReplacementStart,
+        semantics: createMacroSemantics(patchedProgram),
+        sourceFile: patchedSourceFile,
+    };
+}
+export function materializeRegionForHover(fileName, originalText, regionSpan, sourcePosition) {
+    let cursor = regionSpan.start;
+    let output = '';
+    let hoverPosition;
+    const mappings = [];
+    for (const parsed of collectInvocationsInRegion(fileName, originalText, regionSpan)) {
+        if (parsed.span.start < cursor || parsed.span.start >= regionSpan.end) {
+            continue;
+        }
+        output = appendMappedText(output, mappings, originalText.slice(cursor, parsed.span.start), cursor);
+        if (hoverPosition === undefined && sourcePosition < parsed.span.start) {
+            hoverPosition = output.length - (parsed.span.start - sourcePosition);
+        }
+        if (!containsPosition(parsed.span, sourcePosition)) {
+            output += neutralizeMacroInvocation(parsed);
+            cursor = parsed.span.end;
+            continue;
+        }
+        if (containsPosition(parsed.nameSpan, sourcePosition) ||
+            containsPosition(parsed.hashSpan, sourcePosition)) {
+            return {
+                kind: 'macro',
+                invocation: parsed,
+            };
+        }
+        const expressionArguments = parsed.argumentSpans.filter((argument) => argument.kind === 'ExprArg');
+        const hoveredExpressionArgument = expressionArguments.find((argument) => containsPosition(argument.span, sourcePosition));
+        if (hoveredExpressionArgument) {
+            const nested = materializeRegionForHover(fileName, originalText, hoveredExpressionArgument.span, sourcePosition);
+            if (isNestedMacroHoverTarget(nested)) {
+                return nested;
+            }
+            hoverPosition = output.length + nested.hoverPosition;
+            const generatedOffset = output.length;
+            mappings.push(...nested.mappings.map((mapping) => ({
+                generatedStart: mapping.generatedStart + generatedOffset,
+                generatedEnd: mapping.generatedEnd + generatedOffset,
+                sourceStart: mapping.sourceStart,
+                sourceEnd: mapping.sourceEnd,
+            })));
+            output += nested.text;
+            cursor = parsed.span.end;
+            continue;
+        }
+        const blockSpan = getBlockSpan(parsed);
+        if (blockSpan && containsPosition(blockSpan, sourcePosition)) {
+            const nested = materializeRegionForHover(fileName, originalText, blockSpan, sourcePosition);
+            if (isNestedMacroHoverTarget(nested)) {
+                return nested;
+            }
+            hoverPosition = output.length + nested.hoverPosition;
+            const generatedOffset = output.length;
+            mappings.push(...nested.mappings.map((mapping) => ({
+                generatedStart: mapping.generatedStart + generatedOffset,
+                generatedEnd: mapping.generatedEnd + generatedOffset,
+                sourceStart: mapping.sourceStart,
+                sourceEnd: mapping.sourceEnd,
+            })));
+            output += nested.text;
+            cursor = parsed.span.end;
+            continue;
+        }
+        return {
+            kind: 'macro',
+            invocation: parsed,
+        };
+    }
+    output = appendMappedText(output, mappings, originalText.slice(cursor, regionSpan.end), cursor);
+    if (hoverPosition === undefined) {
+        hoverPosition = output.length - (regionSpan.end - sourcePosition);
+    }
+    return {
+        hoverPosition,
+        mappings,
+        text: output,
+    };
+}
+export function materializeRegionForAnalysis(fileName, originalText, regionSpan) {
+    let cursor = regionSpan.start;
+    let output = '';
+    const mappings = [];
+    for (const parsed of collectInvocationsInRegion(fileName, originalText, regionSpan)) {
+        if (parsed.span.start < cursor || parsed.span.start >= regionSpan.end) {
+            continue;
+        }
+        output = appendMappedText(output, mappings, originalText.slice(cursor, parsed.span.start), cursor);
+        output += neutralizeMacroInvocation(parsed);
+        cursor = parsed.span.end;
+    }
+    output = appendMappedText(output, mappings, originalText.slice(cursor, regionSpan.end), cursor);
+    return {
+        hoverPosition: 0,
+        mappings,
+        text: output,
+    };
+}
+function patchMaterializedRegionForCompletion(materializedRegion) {
+    let prefixStart = materializedRegion.hoverPosition;
+    while (prefixStart > 0 && isIdentifierPart(materializedRegion.text[prefixStart - 1])) {
+        prefixStart -= 1;
+    }
+    if (prefixStart > 0 && materializedRegion.text[prefixStart - 1] === '.') {
+        const patchedText = materializedRegion.text.slice(0, materializedRegion.hoverPosition) +
+            COMPLETION_PLACEHOLDER_IDENTIFIER +
+            materializedRegion.text.slice(materializedRegion.hoverPosition);
+        return {
+            lookupPosition: materializedRegion.hoverPosition + COMPLETION_PLACEHOLDER_IDENTIFIER.length -
+                1,
+            text: patchedText,
+        };
+    }
+    return {
+        lookupPosition: Math.max(0, materializedRegion.hoverPosition - 1),
+        text: materializedRegion.text,
+    };
+}
+function resolveNodeFromMaterializedRegion(preparedProgram, resolved, materializedRegion, useCompletionPatch = false) {
+    const patchedMaterializedRegion = useCompletionPatch
+        ? patchMaterializedRegionForCompletion(materializedRegion)
+        : {
+            lookupPosition: materializedRegion.hoverPosition,
+            text: materializedRegion.text,
+        };
+    const patchedSource = createPatchedMacroSource(preparedProgram, resolved, patchedMaterializedRegion.text);
+    if (!patchedSource) {
+        return null;
+    }
+    const patchedPosition = patchedSource.rewrittenStart + patchedMaterializedRegion.lookupPosition;
+    const node = findDeepestNodeContainingPosition(patchedSource.sourceFile, patchedPosition);
+    if (!node || ts.isSourceFile(node) || ts.isBlock(node)) {
+        return null;
+    }
+    return {
+        checker: patchedSource.checker,
+        materializedRegion,
+        node,
+        originalReplacementEnd: patchedSource.originalReplacementEnd,
+        originalReplacementStart: patchedSource.originalReplacementStart,
+        rewrittenStart: patchedSource.rewrittenStart,
+        semantics: patchedSource.semantics,
+        sourceFile: patchedSource.sourceFile,
+    };
+}
+export function wrapMaterializedRegion(materializedRegion, prefixText, suffixText) {
+    const generatedOffset = prefixText.length;
+    return {
+        hoverPosition: generatedOffset + materializedRegion.hoverPosition,
+        mappings: materializedRegion.mappings.map((mapping) => ({
+            generatedStart: mapping.generatedStart + generatedOffset,
+            generatedEnd: mapping.generatedEnd + generatedOffset,
+            sourceStart: mapping.sourceStart,
+            sourceEnd: mapping.sourceEnd,
+        })),
+        text: `${prefixText}${materializedRegion.text}${suffixText}`,
+    };
+}
+export function resolveNodeAtMaterializedRegion(preparedProgram, resolved, materializedRegion) {
+    return resolveNodeFromMaterializedRegion(preparedProgram, resolved, materializedRegion);
+}
+export function resolveCompletionNodeAtMaterializedRegion(preparedProgram, resolved, materializedRegion) {
+    return resolveNodeFromMaterializedRegion(preparedProgram, resolved, materializedRegion, true);
+}
+export function createPatchedMacroRegion(preparedProgram, resolved, materializedRegion) {
+    const patchedSource = createPatchedMacroSource(preparedProgram, resolved, materializedRegion.text);
+    if (!patchedSource) {
+        return null;
+    }
+    return {
+        checker: patchedSource.checker,
+        materializedRegion,
+        originalReplacementEnd: patchedSource.originalReplacementEnd,
+        originalReplacementStart: patchedSource.originalReplacementStart,
+        rewrittenStart: patchedSource.rewrittenStart,
+        semantics: patchedSource.semantics,
+        sourceFile: patchedSource.sourceFile,
+    };
+}
+export function mapMaterializedRangeToSource(materializedRegion, generatedStart, generatedEnd) {
+    const clampedStart = Math.max(0, Math.min(generatedStart, materializedRegion.text.length));
+    const clampedEnd = Math.max(clampedStart, Math.min(generatedEnd, materializedRegion.text.length));
+    const intersectingMappings = materializedRegion.mappings.filter((mapping) => !(clampedEnd <= mapping.generatedStart || clampedStart >= mapping.generatedEnd));
+    if (intersectingMappings.length === 0) {
+        return null;
+    }
+    const first = intersectingMappings[0];
+    const last = intersectingMappings[intersectingMappings.length - 1];
+    const start = first.sourceStart + Math.max(0, clampedStart - first.generatedStart);
+    const end = last.sourceStart + Math.max(0, clampedEnd - last.generatedStart);
+    let previousGeneratedEnd = Math.max(clampedStart, first.generatedStart);
+    let intersectsUnmapped = first.generatedStart > clampedStart;
+    for (const mapping of intersectingMappings) {
+        if (mapping.generatedStart > previousGeneratedEnd) {
+            intersectsUnmapped = true;
+            break;
+        }
+        previousGeneratedEnd = Math.max(previousGeneratedEnd, mapping.generatedEnd);
+    }
+    if (previousGeneratedEnd < clampedEnd) {
+        intersectsUnmapped = true;
+    }
+    return {
+        start,
+        end: Math.max(start, end),
+        intersectsUnmapped,
+    };
+}
+export function resolveExpressionNodeAtSourcePosition(preparedProgram, resolved, sourcePosition) {
+    const invocation = resolved.placeholder.invocation;
+    const expressionArguments = invocation.argumentSpans.filter((argument) => argument.kind === 'ExprArg');
+    const hoveredExpressionArgument = expressionArguments.find((argument) => containsPosition(argument.span, sourcePosition));
+    if (!hoveredExpressionArgument) {
+        return null;
+    }
+    const preparedFile = resolved.placeholder.preparedFile;
+    const materialized = materializeRegionForHover(invocation.fileName, preparedFile.originalText, hoveredExpressionArgument.span, sourcePosition);
+    if (isNestedMacroHoverTarget(materialized)) {
+        return materialized;
+    }
+    return resolveNodeFromMaterializedRegion(preparedProgram, resolved, materialized);
+}
+export function resolveBlockNodeAtSourcePosition(preparedProgram, resolved, sourcePosition) {
+    const blockSpan = getBlockSpan(resolved.placeholder.invocation);
+    if (!blockSpan || sourcePosition < blockSpan.start || sourcePosition >= blockSpan.end) {
+        return null;
+    }
+    const preparedFile = resolved.placeholder.preparedFile;
+    const materialized = materializeRegionForHover(resolved.placeholder.invocation.fileName, preparedFile.originalText, blockSpan, sourcePosition);
+    if (isNestedMacroHoverTarget(materialized)) {
+        return materialized;
+    }
+    const resolvedNode = resolveNodeFromMaterializedRegion(preparedProgram, resolved, materialized);
+    if (!resolvedNode) {
+        return null;
+    }
+    return {
+        ...resolvedNode,
+        originalBlockSpan: blockSpan,
+    };
+}
+export function resolveExpressionCompletionNodeAtSourcePosition(preparedProgram, resolved, sourcePosition) {
+    const invocation = resolved.placeholder.invocation;
+    const expressionArguments = invocation.argumentSpans.filter((argument) => argument.kind === 'ExprArg');
+    const hoveredExpressionArgument = expressionArguments.find((argument) => containsPosition(argument.span, sourcePosition) || argument.span.end === sourcePosition);
+    if (!hoveredExpressionArgument) {
+        return null;
+    }
+    const effectiveSourcePosition = sourcePosition === hoveredExpressionArgument.span.end
+        ? Math.max(hoveredExpressionArgument.span.start, sourcePosition - 1)
+        : sourcePosition;
+    const preparedFile = resolved.placeholder.preparedFile;
+    const materialized = materializeRegionForHover(invocation.fileName, preparedFile.originalText, hoveredExpressionArgument.span, effectiveSourcePosition);
+    if (isNestedMacroHoverTarget(materialized)) {
+        return materialized;
+    }
+    const completionMaterialized = sourcePosition === hoveredExpressionArgument.span.end
+        ? { ...materialized, hoverPosition: materialized.text.length }
+        : materialized;
+    return resolveNodeFromMaterializedRegion(preparedProgram, resolved, completionMaterialized, true);
+}
+export function resolveBlockCompletionNodeAtSourcePosition(preparedProgram, resolved, sourcePosition) {
+    const blockSpan = getBlockSpan(resolved.placeholder.invocation);
+    if (!blockSpan || sourcePosition < blockSpan.start || sourcePosition > blockSpan.end) {
+        return null;
+    }
+    const effectiveSourcePosition = sourcePosition === blockSpan.end
+        ? Math.max(blockSpan.start, sourcePosition - 1)
+        : sourcePosition;
+    const preparedFile = resolved.placeholder.preparedFile;
+    const materialized = materializeRegionForHover(resolved.placeholder.invocation.fileName, preparedFile.originalText, blockSpan, effectiveSourcePosition);
+    if (isNestedMacroHoverTarget(materialized)) {
+        return materialized;
+    }
+    const completionMaterialized = sourcePosition === blockSpan.end
+        ? { ...materialized, hoverPosition: materialized.text.length }
+        : materialized;
+    const resolvedNode = resolveNodeFromMaterializedRegion(preparedProgram, resolved, completionMaterialized, true);
+    if (!resolvedNode) {
+        return null;
+    }
+    return {
+        ...resolvedNode,
+        originalBlockSpan: blockSpan,
+    };
+}
+export function resolveExprArgumentOperand(preparedProgram, resolved, index, nestedRegistries = { advanced: new Map(), rewrite: new Map() }) {
+    const invocation = resolved.placeholder.invocation;
+    const exprSpan = getExprArgumentSpan(invocation, index);
+    if (!exprSpan) {
+        return null;
+    }
+    const replacement = resolved.placeholder.replacement;
+    const preparedFile = resolved.placeholder.preparedFile;
+    const operandText = preparedFile.originalText.slice(exprSpan.start, exprSpan.end);
+    const nestedExpansion = materializeNestedOperandExpansion(preparedProgram, resolved, operandText, nestedRegistries) ?? { expressionText: operandText, preludeTexts: [] };
+    if (!nestedExpansion) {
+        return null;
+    }
+    const expandedText = nestedExpansion.expressionText;
+    const containingStatement = findContainingStatement(resolved.callExpression);
+    const programReplacementStart = mapStageOnePositionToProgram(preparedFile, replacement.rewrittenSpan.start);
+    const programReplacementEnd = mapStageOnePositionToProgram(preparedFile, replacement.rewrittenSpan.end);
+    const statementStart = containingStatement?.getStart(resolved.callExpression.getSourceFile()) ??
+        programReplacementStart;
+    const insertedPrelude = nestedExpansion.preludeTexts.length > 0
+        ? `${nestedExpansion.preludeTexts.join('\n')}\n`
+        : '';
+    const preludeAdjustedText = insertedPrelude.length > 0
+        ? preparedFile.rewrittenText.slice(0, statementStart) + insertedPrelude +
+            preparedFile.rewrittenText.slice(statementStart)
+        : preparedFile.rewrittenText;
+    const replacementOffset = statementStart <= programReplacementStart
+        ? insertedPrelude.length
+        : 0;
+    const patchedExpressionStart = programReplacementStart + replacementOffset;
+    const patchedText = replaceRange(preludeAdjustedText, programReplacementStart + replacementOffset, programReplacementEnd + replacementOffset, expandedText);
+    const rewrittenProgramFileName = preparedProgram.toProgramFileName(replacement.rewrittenSpan.fileName);
+    const overrideHost = {
+        ...preparedProgram.preparedHost.host,
+        getSourceFile(fileName, languageVersion, onError, shouldCreateNewSourceFile) {
+            if (fileName === rewrittenProgramFileName) {
+                return ts.createSourceFile(fileName, patchedText, languageVersion, true);
+            }
+            return preparedProgram.preparedHost.host.getSourceFile(fileName, languageVersion, onError, shouldCreateNewSourceFile);
+        },
+        readFile(fileName) {
+            if (fileName === rewrittenProgramFileName) {
+                return patchedText;
+            }
+            return preparedProgram.preparedHost.host.readFile(fileName);
+        },
+    };
+    const patchedProgram = ts.createProgram({
+        host: overrideHost,
+        options: preparedProgram.options,
+        rootNames: preparedProgram.rootNames.map((fileName) => preparedProgram.toProgramFileName(fileName)),
+    });
+    const patchedSourceFile = patchedProgram.getSourceFile(rewrittenProgramFileName);
+    if (!patchedSourceFile) {
+        return null;
+    }
+    const patchedExpression = findExpressionAtSpan(patchedSourceFile, patchedExpressionStart, patchedExpressionStart + expandedText.length);
+    if (!patchedExpression) {
+        return null;
+    }
+    return {
+        expandedText,
+        preludeTexts: nestedExpansion.preludeTexts,
+        node: patchedExpression,
+        semantics: createMacroSemantics(patchedProgram),
+        sourceFile: patchedSourceFile,
+    };
+}
+export function resolvePrimaryExprOperand(preparedProgram, resolved, nestedRegistries = { advanced: new Map(), rewrite: new Map() }) {
+    const invocation = resolved.placeholder.invocation;
+    if (!_getPrimaryExprSpan(invocation)) {
+        return null;
+    }
+    return resolveExprArgumentOperand(preparedProgram, resolved, 0, nestedRegistries);
+}
+export function typeOfPrimaryExprOperand(preparedProgram, resolved, nestedRegistries = { advanced: new Map(), rewrite: new Map() }) {
+    const operand = resolvePrimaryExprOperand(preparedProgram, resolved, nestedRegistries);
+    return operand ? operand.semantics.typeOfNode(operand.node) : null;
+}
+export function enclosingFunctionOfPrimaryExprOperand(preparedProgram, resolved, nestedRegistries = { advanced: new Map(), rewrite: new Map() }) {
+    const operand = resolvePrimaryExprOperand(preparedProgram, resolved, nestedRegistries);
+    return operand ? operand.semantics.enclosingFunctionOfNode(operand.node) ?? null : null;
+}
+export function classifyCanonicalResultOfPrimaryExprOperand(preparedProgram, resolved, nestedRegistries = { advanced: new Map(), rewrite: new Map() }) {
+    const operand = resolvePrimaryExprOperand(preparedProgram, resolved, nestedRegistries);
+    if (!operand) {
+        return null;
+    }
+    return operand.semantics.classifyCanonicalResultType(operand.semantics.typeOfNode(operand.node));
+}
+export function classifyCanonicalResultCarrierOfPrimaryExprOperand(preparedProgram, resolved, nestedRegistries = { advanced: new Map(), rewrite: new Map() }) {
+    const operand = resolvePrimaryExprOperand(preparedProgram, resolved, nestedRegistries);
+    if (!operand) {
+        return null;
+    }
+    return operand.semantics.classifyCanonicalResultCarrierType(operand.semantics.typeOfNode(operand.node));
+}
+import { getAlwaysAvailableBuiltinMacroSiteKinds } from './builtin_macro_support.js';