@soundscript/soundscript 0.1.13 → 0.1.15

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

@@ -0,0 +1,826 @@
+import ts from 'typescript';
+import { createAnnotationLookup } from '../annotation_syntax.js';
+import { createMacroContext } from './macro_context.js';
+import { createMacroError } from './macro_errors.js';
+import { resolveExprArgumentOperand, resolvePrimaryExprOperand, } from './macro_operand_semantics.js';
+import { createMacroSemantics } from './macro_semantics.js';
+import { createMacroScopeExitOutput, createMacroValueRewriteOutput } from './macro_output.js';
+import { scanMacroCandidates } from './macro_scanner.js';
+import { createDeclSyntaxFromNode, createExprSyntaxFromNode, createStmtListSyntaxFromCode, getHostBlock, getHostExpression, getHostNode, getHostStatement, } from './macro_syntax_internal.js';
+import { synthesizeHostNode } from './macro_host_ast_internal.js';
+function sanitizeBindingHint(hint) {
+    const sanitized = hint.replace(/[^A-Za-z0-9_$]/g, '_');
+    return sanitized.length > 0 ? sanitized : '__sts_macro_tmp';
+}
+function classifyPlacement(resolved) {
+    const callExpression = resolved.callExpression;
+    let current = callExpression;
+    let parent = callExpression.parent;
+    while (parent && !ts.isStatement(parent) && !ts.isSourceFile(parent)) {
+        if (ts.isFunctionLike(parent) &&
+            parent.kind !== ts.SyntaxKind.Constructor &&
+            !(ts.isArrowFunction(parent) && parent.body === current && !ts.isBlock(parent.body))) {
+            return { kind: 'unsupported', reason: 'unsupported-site' };
+        }
+        if (ts.isVariableDeclarationList(parent) && parent.declarations.length !== 1) {
+            return { kind: 'unsupported', reason: 'multi-declaration' };
+        }
+        if (ts.isCallExpression(parent) &&
+            parent.arguments.some((argument) => argument === current)) {
+            const isOptionalCall = !!parent.questionDotToken ||
+                (ts.isPropertyAccessExpression(parent.expression) &&
+                    !!parent.expression.questionDotToken) ||
+                (ts.isElementAccessExpression(parent.expression) && !!parent.expression.questionDotToken);
+            if (isOptionalCall) {
+                current = parent;
+                parent = parent.parent;
+                continue;
+            }
+        }
+        if (ts.isElementAccessExpression(parent) &&
+            parent.questionDotToken &&
+            parent.argumentExpression === current) {
+            current = parent;
+            parent = parent.parent;
+            continue;
+        }
+        if ('questionDotToken' in parent && parent.questionDotToken) {
+            if ('expression' in parent && parent.expression === current) {
+                current = parent;
+                parent = parent.parent;
+                continue;
+            }
+            return { kind: 'unsupported', reason: 'unsupported-site' };
+        }
+        current = parent;
+        parent = parent.parent;
+    }
+    if (!parent || ts.isSourceFile(parent)) {
+        return { kind: 'unsupported', reason: 'unsupported-site' };
+    }
+    if (ts.isVariableStatement(parent)) {
+        const declarationList = parent.declarationList;
+        if (declarationList.declarations.length !== 1) {
+            return { kind: 'unsupported', reason: 'multi-declaration' };
+        }
+        return { kind: 'statement-region' };
+    }
+    if (ts.isExpressionStatement(parent)) {
+        return { kind: 'statement-region' };
+    }
+    if (ts.isReturnStatement(parent) || ts.isThrowStatement(parent)) {
+        return parent.expression === current
+            ? { kind: 'statement-region' }
+            : { kind: 'unsupported', reason: 'unsupported-site' };
+    }
+    if ((ts.isIfStatement(parent) ||
+        ts.isWhileStatement(parent) ||
+        ts.isDoStatement(parent) ||
+        ts.isSwitchStatement(parent) ||
+        ts.isForOfStatement(parent) ||
+        ts.isForInStatement(parent)) &&
+        parent.expression === current) {
+        return { kind: 'statement-region' };
+    }
+    if (ts.isForStatement(parent) &&
+        (parent.initializer === current ||
+            parent.condition === current ||
+            parent.incrementor === current)) {
+        return { kind: 'statement-region' };
+    }
+    return { kind: 'unsupported', reason: 'unsupported-site' };
+}
+export function createAdvancedMacroContext(preparedProgram, resolved, nestedRegistries = { advanced: new Map(), rewrite: new Map() }, runtimeResolver = null, hostAccess) {
+    const baseContext = createMacroContext(resolved, runtimeResolver, hostAccess, preparedProgram.runtime);
+    const hostSemantics = createMacroSemantics(preparedProgram.program);
+    let freshCounter = 0;
+    let primaryExprOperand = undefined;
+    const originalSourceFileCache = new Map();
+    const originalAnnotationLookupCache = new Map();
+    const exprArgumentOperands = new Map();
+    function scriptKindForFileName(fileName) {
+        const lowered = fileName.toLowerCase();
+        if (lowered.endsWith('.sts') || lowered.endsWith('.tsx') || lowered.endsWith('.jsx')) {
+            return ts.ScriptKind.TSX;
+        }
+        if (lowered.endsWith('.js') || lowered.endsWith('.mjs') || lowered.endsWith('.cjs')) {
+            return ts.ScriptKind.JS;
+        }
+        return ts.ScriptKind.TS;
+    }
+    function originalSourceFileForNode(node) {
+        const programFileName = node.getSourceFile().fileName;
+        const sourceFileName = preparedProgram.toSourceFileName(programFileName);
+        const cached = originalSourceFileCache.get(sourceFileName);
+        if (cached) {
+            return cached;
+        }
+        const preparedSource = preparedProgram.preparedHost.getPreparedSourceFile(sourceFileName);
+        const sourceText = preparedSource?.originalText ?? node.getSourceFile().text;
+        const sourceFile = ts.createSourceFile(sourceFileName, sourceText, ts.ScriptTarget.Latest, true, scriptKindForFileName(sourceFileName));
+        originalSourceFileCache.set(sourceFileName, sourceFile);
+        return sourceFile;
+    }
+    function originalAnnotationLookupForNode(node) {
+        const sourceFile = originalSourceFileForNode(node);
+        const cached = originalAnnotationLookupCache.get(sourceFile.fileName);
+        if (cached) {
+            return cached;
+        }
+        const lookup = createAnnotationLookup(sourceFile);
+        originalAnnotationLookupCache.set(sourceFile.fileName, lookup);
+        return lookup;
+    }
+    function originalClassDeclarationForTypeNode(node) {
+        if (!ts.isTypeReferenceNode(node) || !ts.isIdentifier(node.typeName)) {
+            return null;
+        }
+        const sourceFile = originalSourceFileForNode(node);
+        const className = node.typeName.text;
+        let found = null;
+        const visit = (current) => {
+            if (found) {
+                return;
+            }
+            if (ts.isClassDeclaration(current) && current.name?.text === className) {
+                found = current;
+                return;
+            }
+            ts.forEachChild(current, visit);
+        };
+        visit(sourceFile);
+        return found;
+    }
+    function getPrimaryExprOperand() {
+        if (primaryExprOperand === undefined) {
+            primaryExprOperand = resolvePrimaryExprOperand(preparedProgram, resolved, nestedRegistries);
+        }
+        return primaryExprOperand;
+    }
+    function getExprArgumentOperand(index) {
+        if (!exprArgumentOperands.has(index)) {
+            exprArgumentOperands.set(index, resolveExprArgumentOperand(preparedProgram, resolved, index, nestedRegistries));
+        }
+        return exprArgumentOperands.get(index) ?? null;
+    }
+    function exprArgumentIndexForSyntax(expr) {
+        const match = baseContext.invocation.args.find((argument) => argument.span.fileName === expr.span.fileName &&
+            argument.span.start === expr.span.start &&
+            argument.span.end === expr.span.end);
+        return match?.index ?? null;
+    }
+    function findOriginalNodeForSyntaxNode(node) {
+        const hostNode = getHostNode(node);
+        if (!hostNode) {
+            return null;
+        }
+        const sourceFile = originalSourceFileForNode(hostNode);
+        let match = null;
+        const visit = (current) => {
+            if (match) {
+                return;
+            }
+            if (current.getStart(sourceFile, false) === node.span.start &&
+                current.end === node.span.end) {
+                match = current;
+                return;
+            }
+            ts.forEachChild(current, visit);
+        };
+        visit(sourceFile);
+        return match;
+    }
+    function annotationsForNode(node) {
+        const originalNode = findOriginalNodeForSyntaxNode(node);
+        return originalNode
+            ? originalAnnotationLookupForNode(originalNode).getAttachedAnnotations(originalNode)
+            : baseContext.syntax.annotations(node);
+    }
+    function reflectedSyntaxNode(node, kind = 'reflected_syntax') {
+        const sourceFile = node.getSourceFile();
+        return {
+            kind,
+            span: {
+                fileName: sourceFile.fileName,
+                start: node.getStart(sourceFile, false),
+                end: node.end,
+            },
+        };
+    }
+    function propertyNameText(name) {
+        if (ts.isIdentifier(name) || ts.isStringLiteral(name) || ts.isNumericLiteral(name)) {
+            return name.text;
+        }
+        return null;
+    }
+    function simpleTypeReferenceName(typeName) {
+        return ts.isIdentifier(typeName) ? typeName.text : typeName.right.text;
+    }
+    function reflectedTypeText(node) {
+        return node.getText(node.getSourceFile());
+    }
+    function buildReflectedFieldFromTypeMember(member, originKind) {
+        if (!ts.isPropertySignature(member) || !member.name) {
+            return null;
+        }
+        const name = propertyNameText(member.name);
+        if (name === null) {
+            return null;
+        }
+        return {
+            annotations: originalAnnotationLookupForNode(member).getAttachedAnnotations(member),
+            name,
+            node: reflectedSyntaxNode(member, 'type_member'),
+            optional: !!member.questionToken,
+            originKind,
+            text: member.getText(member.getSourceFile()),
+            type: member.type ? buildTypeShapeFromTypeNode(member.type) : null,
+        };
+    }
+    function buildReflectedFieldFromObjectMember(member, originKind) {
+        if (member.memberKind !== 'property_signature' || member.name === null) {
+            return null;
+        }
+        const explicitType = member.explicitType();
+        return {
+            annotations: annotationsForNode(member),
+            name: member.name,
+            node: member,
+            optional: member.isOptional(),
+            originKind,
+            text: member.text(),
+            type: explicitType ? reflectTypeShape(explicitType) : null,
+        };
+    }
+    function buildReflectedFieldFromClassField(field) {
+        if (field.name === null || field.hasModifier('private') || field.hasModifier('protected') ||
+            field.hasModifier('static')) {
+            return null;
+        }
+        const explicitType = field.explicitType();
+        return {
+            annotations: annotationsForNode(field),
+            name: field.name,
+            node: field,
+            optional: field.isOptional(),
+            originKind: 'classField',
+            text: field.text(),
+            type: explicitType ? reflectTypeShape(explicitType) : null,
+        };
+    }
+    function buildObjectFieldShapesFromTypeLiteral(node) {
+        const fields = node.members.map((member) => buildReflectedFieldFromTypeMember(member, 'typeLiteralProperty'));
+        return fields.every((field) => field !== null)
+            ? fields
+            : null;
+    }
+    function buildTypeShapeFromTypeNode(node) {
+        if (ts.isParenthesizedTypeNode(node)) {
+            return buildTypeShapeFromTypeNode(node.type);
+        }
+        if (ts.isTypeOperatorNode(node) && node.operator === ts.SyntaxKind.ReadonlyKeyword) {
+            if (ts.isArrayTypeNode(node.type)) {
+                return {
+                    element: buildTypeShapeFromTypeNode(node.type.elementType),
+                    kind: 'array',
+                    readonly: true,
+                    text: reflectedTypeText(node),
+                };
+            }
+            if (ts.isTupleTypeNode(node.type)) {
+                return {
+                    elements: node.type.elements.map((element) => buildTypeShapeFromTypeNode(element)),
+                    kind: 'tuple',
+                    readonly: true,
+                    text: reflectedTypeText(node),
+                };
+            }
+        }
+        if (ts.isArrayTypeNode(node)) {
+            return {
+                element: buildTypeShapeFromTypeNode(node.elementType),
+                kind: 'array',
+                readonly: false,
+                text: reflectedTypeText(node),
+            };
+        }
+        if (ts.isTupleTypeNode(node)) {
+            return {
+                elements: node.elements.map((element) => buildTypeShapeFromTypeNode(element)),
+                kind: 'tuple',
+                readonly: false,
+                text: reflectedTypeText(node),
+            };
+        }
+        if (ts.isTypeLiteralNode(node)) {
+            const fields = buildObjectFieldShapesFromTypeLiteral(node);
+            return fields
+                ? {
+                    fields,
+                    kind: 'object',
+                    text: reflectedTypeText(node),
+                }
+                : { kind: 'unsupported', text: reflectedTypeText(node) };
+        }
+        if (ts.isUnionTypeNode(node)) {
+            return {
+                kind: 'union',
+                members: node.types.map((member) => buildTypeShapeFromTypeNode(member)),
+                text: reflectedTypeText(node),
+            };
+        }
+        if (ts.isLiteralTypeNode(node)) {
+            if (ts.isStringLiteral(node.literal)) {
+                return {
+                    kind: 'literal',
+                    literalKind: 'string',
+                    text: reflectedTypeText(node),
+                    value: node.literal.text,
+                };
+            }
+            if (ts.isNumericLiteral(node.literal)) {
+                return {
+                    kind: 'literal',
+                    literalKind: 'number',
+                    text: reflectedTypeText(node),
+                    value: Number(node.literal.text),
+                };
+            }
+            if (node.literal.kind === ts.SyntaxKind.TrueKeyword) {
+                return {
+                    kind: 'literal',
+                    literalKind: 'boolean',
+                    text: reflectedTypeText(node),
+                    value: true,
+                };
+            }
+            if (node.literal.kind === ts.SyntaxKind.FalseKeyword) {
+                return {
+                    kind: 'literal',
+                    literalKind: 'boolean',
+                    text: reflectedTypeText(node),
+                    value: false,
+                };
+            }
+            return { kind: 'unsupported', text: reflectedTypeText(node) };
+        }
+        switch (node.kind) {
+            case ts.SyntaxKind.StringKeyword:
+                return {
+                    kind: 'primitive',
+                    primitiveKind: 'string',
+                    text: reflectedTypeText(node),
+                };
+            case ts.SyntaxKind.NumberKeyword:
+                return {
+                    kind: 'primitive',
+                    primitiveKind: 'number',
+                    text: reflectedTypeText(node),
+                };
+            case ts.SyntaxKind.BooleanKeyword:
+                return {
+                    kind: 'primitive',
+                    primitiveKind: 'boolean',
+                    text: reflectedTypeText(node),
+                };
+            case ts.SyntaxKind.BigIntKeyword:
+                return {
+                    kind: 'primitive',
+                    primitiveKind: 'bigint',
+                    text: reflectedTypeText(node),
+                };
+        }
+        if (ts.isTypeReferenceNode(node)) {
+            const name = node.typeName.getText(node.getSourceFile());
+            const simpleName = simpleTypeReferenceName(node.typeName);
+            const typeArguments = (node.typeArguments ?? []).map((argument) => buildTypeShapeFromTypeNode(argument));
+            if (simpleName === 'Option' && typeArguments.length === 1) {
+                return {
+                    kind: 'option',
+                    text: reflectedTypeText(node),
+                    value: typeArguments[0],
+                };
+            }
+            if (simpleName === 'Result' && typeArguments.length === 2) {
+                return {
+                    err: typeArguments[1],
+                    kind: 'result',
+                    ok: typeArguments[0],
+                    text: reflectedTypeText(node),
+                };
+            }
+            if (simpleName === 'Array' && typeArguments.length === 1) {
+                return {
+                    element: typeArguments[0],
+                    kind: 'array',
+                    readonly: false,
+                    text: reflectedTypeText(node),
+                };
+            }
+            if (simpleName === 'ReadonlyArray' && typeArguments.length === 1) {
+                return {
+                    element: typeArguments[0],
+                    kind: 'array',
+                    readonly: true,
+                    text: reflectedTypeText(node),
+                };
+            }
+            return {
+                kind: 'named',
+                name,
+                text: reflectedTypeText(node),
+                typeArguments,
+            };
+        }
+        return { kind: 'unsupported', text: reflectedTypeText(node) };
+    }
+    function reflectTypeShape(type) {
+        const originalNode = findOriginalNodeForSyntaxNode(type);
+        if (originalNode && ts.isTypeNode(originalNode)) {
+            return buildTypeShapeFromTypeNode(originalNode);
+        }
+        const hostNode = getHostNode(type);
+        if (hostNode && ts.isTypeNode(hostNode)) {
+            return buildTypeShapeFromTypeNode(hostNode);
+        }
+        return { kind: 'unsupported', text: type.text() };
+    }
+    function reflectObjectLikeDeclarationShape(declaration) {
+        if (declaration.declarationKind === 'class') {
+            const fields = declaration.members()
+                .filter((member) => member.memberKind === 'field')
+                .map((member) => buildReflectedFieldFromClassField(member))
+                .filter((field) => field !== null);
+            return {
+                declarationKind: 'class',
+                fields,
+                kind: 'objectLike',
+                name: declaration.name,
+                node: declaration,
+                text: declaration.text(),
+            };
+        }
+        if (declaration.declarationKind === 'interface') {
+            const fields = declaration.members.map((member) => buildReflectedFieldFromObjectMember(member, 'interfaceProperty'));
+            if (!fields.every((field) => field !== null)) {
+                return {
+                    kind: 'unsupported',
+                    node: declaration,
+                    reason: 'notObjectLike',
+                    text: declaration.text(),
+                };
+            }
+            return {
+                declarationKind: 'interface',
+                fields: fields,
+                kind: 'objectLike',
+                name: declaration.name,
+                node: declaration,
+                text: declaration.text(),
+            };
+        }
+        const objectType = declaration.type.asObjectLiteral();
+        if (!objectType) {
+            return {
+                kind: 'unsupported',
+                node: declaration,
+                reason: 'notObjectLike',
+                text: declaration.text(),
+            };
+        }
+        const fields = objectType.members.map((member) => buildReflectedFieldFromObjectMember(member, 'typeLiteralProperty'));
+        if (!fields.every((field) => field !== null)) {
+            return {
+                kind: 'unsupported',
+                node: declaration,
+                reason: 'notObjectLike',
+                text: declaration.text(),
+            };
+        }
+        return {
+            declarationKind: 'typeAlias',
+            fields: fields,
+            kind: 'objectLike',
+            name: declaration.name,
+            node: declaration,
+            text: declaration.text(),
+        };
+    }
+    function discriminantsForVariantObjectType(objectType) {
+        const discriminants = [];
+        const fields = [];
+        for (const member of objectType.members) {
+            const reflectedField = buildReflectedFieldFromObjectMember(member, 'typeLiteralProperty');
+            if (!reflectedField) {
+                return null;
+            }
+            const explicitType = member.explicitType();
+            const literal = explicitType?.asLiteral();
+            if (literal?.literalKind === 'string') {
+                discriminants.push({
+                    name: reflectedField.name,
+                    tag: String(literal.value),
+                });
+                continue;
+            }
+            fields.push(reflectedField);
+        }
+        return discriminants.length === 0 ? null : { discriminants, fields };
+    }
+    function reflectDeclarationShape(declaration) {
+        const classDecl = declaration.asClass();
+        if (classDecl) {
+            return reflectObjectLikeDeclarationShape(classDecl);
+        }
+        const interfaceDecl = declaration.asInterface();
+        if (interfaceDecl) {
+            return reflectObjectLikeDeclarationShape(interfaceDecl);
+        }
+        const typeAliasDecl = declaration.asTypeAlias();
+        if (!typeAliasDecl) {
+            return {
+                kind: 'unsupported',
+                node: declaration,
+                reason: 'unsupportedDeclarationKind',
+                text: declaration.text(),
+            };
+        }
+        const objectLike = reflectObjectLikeDeclarationShape(typeAliasDecl);
+        if (objectLike.kind === 'objectLike') {
+            return objectLike;
+        }
+        const unionType = typeAliasDecl.type.asUnion();
+        if (!unionType) {
+            return objectLike;
+        }
+        const variants = [];
+        for (const member of unionType.members) {
+            const objectType = member.asObjectLiteral();
+            if (!objectType) {
+                return {
+                    kind: 'unsupported',
+                    node: declaration,
+                    reason: 'notDiscriminatedUnion',
+                    text: declaration.text(),
+                };
+            }
+            const variant = discriminantsForVariantObjectType(objectType);
+            if (!variant) {
+                return {
+                    kind: 'unsupported',
+                    node: declaration,
+                    reason: 'notDiscriminatedUnion',
+                    text: declaration.text(),
+                };
+            }
+            variants.push({
+                discriminants: variant.discriminants,
+                fields: variant.fields,
+                node: member,
+                text: member.text(),
+            });
+        }
+        const commonDiscriminantNames = variants
+            .map((variant) => new Set(variant.discriminants.map((discriminant) => discriminant.name)))
+            .reduce((current, names) => {
+            if (current === null) {
+                return new Set(names);
+            }
+            return new Set([...current].filter((name) => names.has(name)));
+        }, null);
+        if (!commonDiscriminantNames || commonDiscriminantNames.size === 0) {
+            return {
+                kind: 'unsupported',
+                node: declaration,
+                reason: 'notDiscriminatedUnion',
+                text: declaration.text(),
+            };
+        }
+        return {
+            commonDiscriminantNames: [...commonDiscriminantNames],
+            kind: 'discriminatedUnion',
+            name: typeAliasDecl.name,
+            node: typeAliasDecl,
+            text: typeAliasDecl.text(),
+            variants,
+        };
+    }
+    return {
+        ...baseContext,
+        controlFlow: {
+            deferCleanup(cleanup) {
+                const statements = Array.isArray(cleanup)
+                    ? cleanup.map((statement) => synthesizeHostNode(getHostStatement(statement)))
+                    : getHostBlock(cleanup).statements.map((statement) => synthesizeHostNode(statement));
+                return createMacroScopeExitOutput(statements, baseContext.runtimeImports());
+            },
+            freshBinding(hint) {
+                freshCounter += 1;
+                return `${sanitizeBindingHint(hint)}_${resolved.placeholder.id}_${freshCounter}`;
+            },
+            placement() {
+                return classifyPlacement(resolved);
+            },
+            rewriteWithValue(preludeStatements, replacementExpr) {
+                const placement = classifyPlacement(resolved);
+                if (placement.kind === 'unsupported') {
+                    const message = placement.reason === 'multi-declaration'
+                        ? 'Semantic control-flow rewrites currently only support declarations with a single variable declarator.'
+                        : 'Semantic control-flow rewrites currently only support expression sites that can be hoisted through the nearest enclosing statement.';
+                    throw createMacroError(resolved, message);
+                }
+                return createMacroValueRewriteOutput(preludeStatements.map((statement) => synthesizeHostNode(getHostStatement(statement))), synthesizeHostNode(getHostExpression(replacementExpr)), baseContext.runtimeImports());
+            },
+        },
+        syntax: {
+            ...baseContext.syntax,
+            annotations(node) {
+                return annotationsForNode(node);
+            },
+        },
+        reflect: {
+            declarationShape(declaration) {
+                return reflectDeclarationShape(declaration);
+            },
+            typeShape(type) {
+                return reflectTypeShape(type);
+            },
+        },
+        semantics: {
+            argExpanded(index) {
+                const operand = getExprArgumentOperand(index);
+                return operand
+                    ? createExprSyntaxFromNode(operand.node, operand.sourceFile, baseContext.invocation.args[index]?.span ?? baseContext.invocationSpan(), operand.expandedText)
+                    : null;
+            },
+            argType(index) {
+                const operand = getExprArgumentOperand(index);
+                return operand ? operand.semantics.typeOfNode(operand.node) : null;
+            },
+            awaitedType(type) {
+                return hostSemantics.awaitedType(type);
+            },
+            classDeclarationOfType(type) {
+                const hostNode = getHostNode(type);
+                if (!hostNode || !ts.isTypeNode(hostNode)) {
+                    return null;
+                }
+                const classDeclaration = hostSemantics.classDeclarationOfTypeNode(hostNode) ??
+                    originalClassDeclarationForTypeNode(hostNode);
+                if (!classDeclaration) {
+                    return null;
+                }
+                const sourceFile = classDeclaration.getSourceFile();
+                return createDeclSyntaxFromNode(classDeclaration, sourceFile, {
+                    fileName: sourceFile.fileName,
+                    start: classDeclaration.getStart(sourceFile),
+                    end: classDeclaration.getEnd(),
+                }).asClass();
+            },
+            classifyCanonicalFailureType(type) {
+                return hostSemantics.classifyCanonicalFailureType(type);
+            },
+            classifyCanonicalResultType(type) {
+                return hostSemantics.classifyCanonicalResultType(type);
+            },
+            classifyTryCarrierType(type) {
+                return hostSemantics.classifyTryCarrierType(type);
+            },
+            exprType(expr) {
+                const hostNode = getHostNode(expr);
+                if (hostNode) {
+                    return hostSemantics.typeOfNode(hostNode);
+                }
+                const index = exprArgumentIndexForSyntax(expr);
+                return index === null ? null : this.argType(index);
+            },
+            classifyCanonicalResultCarrierType(type) {
+                return hostSemantics.classifyCanonicalResultCarrierType(type);
+            },
+            enclosingFunction() {
+                return hostSemantics.enclosingFunctionOfNode(resolved.callExpression) ?? null;
+            },
+            enclosingFunctionCanonicalResult() {
+                return hostSemantics.canonicalResultOfEnclosingFunctionNode(resolved.callExpression) ??
+                    null;
+            },
+            finiteCases(type) {
+                return hostSemantics.finiteCases(type);
+            },
+            isAssignable(from, to) {
+                return hostSemantics.isAssignable(from, to);
+            },
+            localDeclarationHasAnnotation(name, annotationName, node) {
+                const hostNode = node
+                    ? findOriginalNodeForSyntaxNode(node) ??
+                        getHostNode(node)?.getSourceFile() ??
+                        resolved.callExpression
+                    : resolved.callExpression;
+                if (!hostNode) {
+                    return false;
+                }
+                const sourceFile = originalSourceFileForNode(hostNode);
+                const annotationLookup = originalAnnotationLookupForNode(hostNode);
+                return sourceFile.statements.some((statement) => {
+                    if (!(ts.isClassDeclaration(statement) ||
+                        ts.isFunctionDeclaration(statement) ||
+                        ts.isInterfaceDeclaration(statement) ||
+                        ts.isTypeAliasDeclaration(statement))) {
+                        return false;
+                    }
+                    return statement.name?.text === name &&
+                        annotationLookup.hasAttachedAnnotation(statement, annotationName);
+                });
+            },
+            nullType() {
+                return hostSemantics.nullType();
+            },
+            parameterType(parameter) {
+                const node = getHostNode(parameter);
+                return node ? hostSemantics.typeOfNode(node) : null;
+            },
+            primaryExprEnclosingFunction() {
+                const operand = getPrimaryExprOperand();
+                return operand ? operand.semantics.enclosingFunctionOfNode(operand.node) ?? null : null;
+            },
+            primaryExprEnclosingFunctionCanonicalResult() {
+                const operand = getPrimaryExprOperand();
+                return operand
+                    ? operand.semantics.canonicalResultOfEnclosingFunctionNode(operand.node) ?? null
+                    : null;
+            },
+            primaryExprExpanded() {
+                const operand = getPrimaryExprOperand();
+                return operand
+                    ? createExprSyntaxFromNode(operand.node, operand.sourceFile, baseContext.syntax.primaryExpr().span, operand.expandedText)
+                    : null;
+            },
+            primaryExprPrelude() {
+                const operand = getPrimaryExprOperand();
+                return operand
+                    ? operand.preludeTexts.flatMap((statementText, index) => createStmtListSyntaxFromCode(resolved.callExpression.getSourceFile().fileName, `macro_primary_expr_prelude_${index}`, statementText))
+                    : null;
+            },
+            primaryExprCanonicalResultCarrier() {
+                const operand = getPrimaryExprOperand();
+                return operand
+                    ? operand.semantics.classifyCanonicalResultCarrierType(operand.semantics.typeOfNode(operand.node))
+                    : null;
+            },
+            primaryExprCanonicalResult() {
+                const operand = getPrimaryExprOperand();
+                return operand
+                    ? operand.semantics.classifyCanonicalResultType(operand.semantics.typeOfNode(operand.node))
+                    : null;
+            },
+            primaryExprContainsMacroInvocations() {
+                if (baseContext.invocation.form !== 'arglist' || baseContext.invocation.args.length !== 1 ||
+                    baseContext.hasBlock() || resolved.placeholder.invocation.declarationSpan) {
+                    return false;
+                }
+                return scanMacroCandidates(resolved.placeholder.invocation.fileName, baseContext.syntax.primaryExpr().text()).hashes.some((hash) => hash.kind === 'macro-start');
+            },
+            primaryExprTryCarrier() {
+                const operand = getPrimaryExprOperand();
+                return operand
+                    ? operand.semantics.classifyTryCarrierType(operand.semantics.typeOfNode(operand.node))
+                    : null;
+            },
+            primaryExprType() {
+                const operand = getPrimaryExprOperand();
+                return operand ? operand.semantics.typeOfNode(operand.node) : null;
+            },
+            readSet(node) {
+                const hostNode = getHostNode(node);
+                return hostNode
+                    ? hostSemantics.readSetOfNode(hostNode)
+                    : { dependencies: [], unknown: false };
+            },
+            undefinedType() {
+                return hostSemantics.undefinedType();
+            },
+            valueBindingCallableInScope(name, node) {
+                const hostNode = node
+                    ? findOriginalNodeForSyntaxNode(node) ??
+                        getHostNode(node)?.getSourceFile() ??
+                        resolved.callExpression
+                    : resolved.callExpression;
+                return hostNode ? hostSemantics.valueBindingCallableInScope(name, hostNode) : false;
+            },
+            valueBindingInScope(name, node) {
+                const hostNode = node
+                    ? findOriginalNodeForSyntaxNode(node) ??
+                        getHostNode(node)?.getSourceFile() ??
+                        resolved.callExpression
+                    : resolved.callExpression;
+                return hostNode ? hostSemantics.valueBindingInScope(name, hostNode) : false;
+            },
+            writeSet(node) {
+                const hostNode = getHostNode(node);
+                return hostNode
+                    ? hostSemantics.writeSetOfNode(hostNode)
+                    : { dependencies: [], unknown: false };
+            },
+        },
+    };
+}