@soundscript/soundscript 0.1.12 → 0.1.15

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

@@ -0,0 +1,1172 @@
+import ts from 'typescript';
+import { ERROR_STDLIB_DECLARATION_FILE } from './error_stdlib_support.js';
+import { RESULT_STDLIB_DECLARATION_FILE, STDLIB_DECLARATION_FILE } from './std_package_support.js';
+import { toSourceFileName } from './project_frontend.js';
+const INTERNAL_TS_TYPE = Symbol('macroTsType');
+const INTERNAL_TS_CHECKER = Symbol('macroTsChecker');
+const MAX_FINITE_CASE_COMBINATIONS = 64;
+const BUILTIN_RUNTIME_CONSTRUCTOR_NAMES = new Set([
+    'AggregateError',
+    'ArrayBuffer',
+    'BigInt64Array',
+    'BigUint64Array',
+    'DataView',
+    'Date',
+    'Error',
+    'EvalError',
+    'Float32Array',
+    'Float64Array',
+    'Int16Array',
+    'Int32Array',
+    'Int8Array',
+    'Map',
+    'Promise',
+    'RangeError',
+    'ReferenceError',
+    'RegExp',
+    'Set',
+    'SharedArrayBuffer',
+    'SyntaxError',
+    'TypeError',
+    'URIError',
+    'URL',
+    'URLSearchParams',
+    'Uint16Array',
+    'Uint32Array',
+    'Uint8Array',
+    'Uint8ClampedArray',
+    'WeakMap',
+    'WeakSet',
+]);
+function createSourceSpan(node) {
+    const sourceFile = node.getSourceFile();
+    return {
+        fileName: sourceFile.fileName,
+        start: node.getStart(sourceFile),
+        end: node.getEnd(),
+    };
+}
+function createMacroType(checker, type) {
+    return {
+        [INTERNAL_TS_CHECKER]: checker,
+        [INTERNAL_TS_TYPE]: type,
+        displayText: checker.typeToString(type),
+    };
+}
+function getInternalType(type) {
+    return type[INTERNAL_TS_TYPE];
+}
+function getInternalChecker(type) {
+    return type[INTERNAL_TS_CHECKER];
+}
+function getNodeType(checker, node) {
+    return ts.isTypeNode(node) ? checker.getTypeFromTypeNode(node) : checker.getTypeAtLocation(node);
+}
+function getFunctionReturnType(checker, node) {
+    if (!ts.isFunctionLike(node) ||
+        node.kind === ts.SyntaxKind.Constructor) {
+        return undefined;
+    }
+    const signature = checker.getSignatureFromDeclaration(node);
+    return signature ? checker.getReturnTypeOfSignature(signature) : undefined;
+}
+function isAsyncFunctionLike(node) {
+    return ts.canHaveModifiers(node) &&
+        ts.getModifiers(node)?.some((modifier) => modifier.kind === ts.SyntaxKind.AsyncKeyword) ===
+            true;
+}
+function isGeneratorFunctionLike(node) {
+    return 'asteriskToken' in node && !!node.asteriskToken;
+}
+function getDeclarationNameText(name) {
+    if (!name) {
+        return undefined;
+    }
+    if (ts.isIdentifier(name) || ts.isStringLiteralLike(name) || ts.isNumericLiteral(name)) {
+        return name.text;
+    }
+    return undefined;
+}
+function getFunctionLikeName(node) {
+    if (ts.isFunctionDeclaration(node) || ts.isFunctionExpression(node) || ts.isMethodDeclaration(node)) {
+        const directName = getDeclarationNameText(node.name);
+        if (directName) {
+            return directName;
+        }
+    }
+    if (ts.isArrowFunction(node) || ts.isFunctionExpression(node)) {
+        const parent = node.parent;
+        if (parent && ts.isVariableDeclaration(parent) && ts.isIdentifier(parent.name)) {
+            return parent.name.text;
+        }
+        if (parent && ts.isPropertyAssignment(parent) && ts.isIdentifier(parent.name)) {
+            return parent.name.text;
+        }
+    }
+    return undefined;
+}
+function getTypeSymbol(type) {
+    return type.aliasSymbol ?? type.getSymbol();
+}
+function resolveClassDeclarationForTypeNode(checker, node) {
+    const type = checker.getTypeFromTypeNode(node);
+    const symbol = (() => {
+        if (ts.isTypeReferenceNode(node)) {
+            return checker.getSymbolAtLocation(node.typeName) ?? getTypeSymbol(type);
+        }
+        return getTypeSymbol(type);
+    })();
+    if (!symbol) {
+        return null;
+    }
+    return resolveAliasedSymbol(checker, symbol).declarations?.find(ts.isClassDeclaration) ?? null;
+}
+function resolveAliasedSymbol(checker, symbol) {
+    return (symbol.flags & ts.SymbolFlags.Alias) !== 0 ? checker.getAliasedSymbol(symbol) : symbol;
+}
+function symbolHasValueMeaning(checker, symbol) {
+    return (resolveAliasedSymbol(checker, symbol).flags & ts.SymbolFlags.Value) !== 0;
+}
+function getValuePathBindingInScope(checker, node, name) {
+    const segments = name.split('.').map((segment) => segment.trim()).filter((segment) => segment.length > 0);
+    const [root, ...rest] = segments;
+    if (!root) {
+        return null;
+    }
+    const rootSymbol = checker.getSymbolsInScope(node, ts.SymbolFlags.Value | ts.SymbolFlags.Alias)
+        .find((symbol) => symbol.getName() === root && symbolHasValueMeaning(checker, symbol));
+    if (!rootSymbol) {
+        return null;
+    }
+    const fromAlias = (rootSymbol.flags & ts.SymbolFlags.Alias) !== 0;
+    let currentType = checker.getTypeOfSymbolAtLocation(rootSymbol, node);
+    let currentSymbol = resolveAliasedSymbol(checker, rootSymbol);
+    for (const segment of rest) {
+        const property = checker.getPropertyOfType(currentType, segment);
+        if (!property) {
+            return null;
+        }
+        currentSymbol = property;
+        currentType = checker.getTypeOfSymbolAtLocation(property, node);
+    }
+    return {
+        fromAlias,
+        symbol: resolveAliasedSymbol(checker, currentSymbol),
+        type: currentType,
+    };
+}
+function declarationIsCallable(declaration) {
+    return ts.isFunctionDeclaration(declaration) ||
+        ts.isMethodDeclaration(declaration) ||
+        ts.isMethodSignature(declaration) ||
+        ts.isCallSignatureDeclaration(declaration) ||
+        (ts.isVariableDeclaration(declaration) &&
+            declaration.initializer !== undefined &&
+            (ts.isArrowFunction(declaration.initializer) ||
+                ts.isFunctionExpression(declaration.initializer)));
+}
+function unwrapDependencyNode(node) {
+    let current = node;
+    while (ts.isParenthesizedExpression(current) ||
+        ts.isAsExpression(current) ||
+        ts.isSatisfiesExpression(current) ||
+        ts.isNonNullExpression(current) ||
+        ts.isPartiallyEmittedExpression(current) ||
+        ts.isTypeAssertionExpression(current)) {
+        current = current.expression;
+    }
+    return current;
+}
+function isAssignmentOperatorToken(kind) {
+    return kind >= ts.SyntaxKind.FirstAssignment && kind <= ts.SyntaxKind.LastAssignment;
+}
+function isCompoundAssignmentOperatorToken(kind) {
+    return kind !== ts.SyntaxKind.EqualsToken && isAssignmentOperatorToken(kind);
+}
+function isDeclarationNameIdentifier(node) {
+    const parent = node.parent;
+    if (!parent) {
+        return false;
+    }
+    return ((ts.isVariableDeclaration(parent) && parent.name === node) ||
+        (ts.isParameter(parent) && parent.name === node) ||
+        (ts.isBindingElement(parent) && parent.name === node) ||
+        (ts.isFunctionDeclaration(parent) && parent.name === node) ||
+        (ts.isFunctionExpression(parent) && parent.name === node) ||
+        (ts.isClassDeclaration(parent) && parent.name === node) ||
+        (ts.isClassExpression(parent) && parent.name === node) ||
+        (ts.isMethodDeclaration(parent) && parent.name === node) ||
+        (ts.isPropertyDeclaration(parent) && parent.name === node) ||
+        (ts.isPropertySignature(parent) && parent.name === node) ||
+        (ts.isMethodSignature(parent) && parent.name === node) ||
+        (ts.isPropertyAssignment(parent) && parent.name === node) ||
+        (ts.isShorthandPropertyAssignment(parent) && parent.name === node && !!parent.objectAssignmentInitializer) ||
+        (ts.isEnumMember(parent) && parent.name === node) ||
+        (ts.isTypeAliasDeclaration(parent) && parent.name === node) ||
+        (ts.isInterfaceDeclaration(parent) && parent.name === node) ||
+        (ts.isTypeParameterDeclaration(parent) && parent.name === node) ||
+        (ts.isImportSpecifier(parent) && (parent.name === node || parent.propertyName === node)) ||
+        (ts.isImportClause(parent) && parent.name === node) ||
+        (ts.isNamespaceImport(parent) && parent.name === node) ||
+        (ts.isImportEqualsDeclaration(parent) && parent.name === node) ||
+        (ts.isLabeledStatement(parent) && parent.label === node) ||
+        (ts.isBreakOrContinueStatement(parent) && parent.label === node) ||
+        (ts.isJsxAttribute(parent) && parent.name === node) ||
+        (ts.isJsxOpeningElement(parent) && parent.tagName === node) ||
+        (ts.isJsxSelfClosingElement(parent) && parent.tagName === node) ||
+        (ts.isJsxClosingElement(parent) && parent.tagName === node));
+}
+function isReferenceIdentifier(node) {
+    const parent = node.parent;
+    if (!parent) {
+        return true;
+    }
+    if (isDeclarationNameIdentifier(node)) {
+        return false;
+    }
+    if (ts.isPropertyAccessExpression(parent) && parent.name === node) {
+        return false;
+    }
+    if (ts.isQualifiedName(parent)) {
+        return false;
+    }
+    if (ts.isTypeReferenceNode(parent) || ts.isExpressionWithTypeArguments(parent)) {
+        return false;
+    }
+    return true;
+}
+function collectDeclaredValueSymbols(checker, root) {
+    const names = new Set();
+    const symbols = new Set();
+    function addBindingName(name) {
+        if (!name) {
+            return;
+        }
+        if (ts.isIdentifier(name)) {
+            names.add(name.text);
+            const symbol = checker.getSymbolAtLocation(name);
+            if (symbol) {
+                symbols.add(resolveAliasedSymbol(checker, symbol));
+            }
+            return;
+        }
+        if (ts.isObjectBindingPattern(name) || ts.isArrayBindingPattern(name)) {
+            for (const element of name.elements) {
+                if (ts.isOmittedExpression(element)) {
+                    continue;
+                }
+                addBindingName(element.name);
+            }
+        }
+    }
+    function visit(node) {
+        if (ts.isVariableDeclaration(node)) {
+            addBindingName(node.name);
+        }
+        else if (ts.isParameter(node)) {
+            addBindingName(node.name);
+        }
+        else if (ts.isFunctionDeclaration(node) || ts.isFunctionExpression(node)) {
+            addBindingName(node.name);
+        }
+        else if (ts.isClassDeclaration(node) || ts.isClassExpression(node)) {
+            addBindingName(node.name);
+        }
+        else if (ts.isImportClause(node)) {
+            addBindingName(node.name);
+        }
+        else if (ts.isNamespaceImport(node)) {
+            addBindingName(node.name);
+        }
+        else if (ts.isImportSpecifier(node)) {
+            addBindingName(node.name);
+        }
+        ts.forEachChild(node, visit);
+    }
+    visit(root);
+    return { names, symbols };
+}
+function createDependencySetBuilder() {
+    const dependencies = new Map();
+    let unknown = false;
+    return {
+        add(kind, name) {
+            dependencies.set(`${kind}:${name}`, { kind, name });
+        },
+        markUnknown() {
+            unknown = true;
+        },
+        build() {
+            return {
+                dependencies: [...dependencies.values()],
+                unknown,
+            };
+        },
+    };
+}
+function collectDependencySets(checker, root) {
+    const localDeclarations = collectDeclaredValueSymbols(checker, root);
+    const rootSourceFile = root.getSourceFile();
+    const rootStart = root.getStart(rootSourceFile, false);
+    const rootEnd = root.end;
+    const reads = createDependencySetBuilder();
+    const writes = createDependencySetBuilder();
+    function symbolDeclaredWithinRoot(symbol) {
+        return (resolveAliasedSymbol(checker, symbol).declarations ?? []).some((declaration) => {
+            const sourceFile = declaration.getSourceFile();
+            return sourceFile === rootSourceFile &&
+                declaration.getStart(sourceFile, false) >= rootStart &&
+                declaration.end <= rootEnd;
+        });
+    }
+    function addBinding(builder, identifier) {
+        if (!isReferenceIdentifier(identifier)) {
+            return;
+        }
+        if (localDeclarations.names.has(identifier.text)) {
+            return;
+        }
+        const symbol = checker.getSymbolAtLocation(identifier);
+        if (symbol) {
+            const resolved = resolveAliasedSymbol(checker, symbol);
+            if (localDeclarations.symbols.has(resolved) ||
+                symbolDeclaredWithinRoot(resolved)) {
+                return;
+            }
+        }
+        builder.add('binding', identifier.text);
+    }
+    function collectAccessRoot(node, builder, includeDynamicReads) {
+        const current = unwrapDependencyNode(node);
+        if (ts.isIdentifier(current)) {
+            addBinding(builder, current);
+            return;
+        }
+        if (current.kind === ts.SyntaxKind.ThisKeyword) {
+            return;
+        }
+        if (ts.isPropertyAccessExpression(current)) {
+            const base = unwrapDependencyNode(current.expression);
+            if (base.kind === ts.SyntaxKind.ThisKeyword) {
+                builder.add('this-member', current.name.text);
+                return;
+            }
+            collectAccessRoot(current.expression, builder, includeDynamicReads);
+            return;
+        }
+        if (ts.isElementAccessExpression(current)) {
+            const base = unwrapDependencyNode(current.expression);
+            if (base.kind === ts.SyntaxKind.ThisKeyword) {
+                builder.markUnknown();
+            }
+            else {
+                collectAccessRoot(current.expression, builder, includeDynamicReads);
+                builder.markUnknown();
+            }
+            if (includeDynamicReads && current.argumentExpression) {
+                collectReadDependencies(current.argumentExpression);
+            }
+            return;
+        }
+        collectReadDependencies(current);
+    }
+    function collectAssignmentTarget(node) {
+        const current = unwrapDependencyNode(node);
+        if (ts.isIdentifier(current)) {
+            addBinding(writes, current);
+            return;
+        }
+        if (ts.isPropertyAccessExpression(current) || ts.isElementAccessExpression(current)) {
+            collectAccessRoot(current, writes, false);
+            if (ts.isElementAccessExpression(current)) {
+                writes.markUnknown();
+            }
+            return;
+        }
+        if (ts.isArrayLiteralExpression(current)) {
+            for (const element of current.elements) {
+                if (ts.isOmittedExpression(element)) {
+                    continue;
+                }
+                if (ts.isSpreadElement(element)) {
+                    collectAssignmentTarget(element.expression);
+                }
+                else {
+                    collectAssignmentTarget(element);
+                }
+            }
+            return;
+        }
+        if (ts.isObjectLiteralExpression(current)) {
+            for (const property of current.properties) {
+                if (ts.isShorthandPropertyAssignment(property)) {
+                    collectAssignmentTarget(property.name);
+                }
+                else if (ts.isPropertyAssignment(property)) {
+                    collectAssignmentTarget(property.initializer);
+                }
+                else if (ts.isSpreadAssignment(property)) {
+                    collectAssignmentTarget(property.expression);
+                }
+            }
+            return;
+        }
+        writes.markUnknown();
+    }
+    function collectReadDependencies(node) {
+        const current = unwrapDependencyNode(node);
+        if (ts.isIdentifier(current)) {
+            addBinding(reads, current);
+            return;
+        }
+        if (ts.isPropertyAccessExpression(current)) {
+            const parent = current.parent;
+            if ((ts.isPropertyAccessExpression(parent) || ts.isElementAccessExpression(parent)) &&
+                parent.expression === current) {
+                return;
+            }
+            collectAccessRoot(current, reads, true);
+            return;
+        }
+        if (ts.isElementAccessExpression(current)) {
+            const parent = current.parent;
+            if ((ts.isPropertyAccessExpression(parent) || ts.isElementAccessExpression(parent)) &&
+                parent.expression === current) {
+                return;
+            }
+            collectAccessRoot(current, reads, true);
+            return;
+        }
+        if (ts.isBinaryExpression(current) && isAssignmentOperatorToken(current.operatorToken.kind)) {
+            if (isCompoundAssignmentOperatorToken(current.operatorToken.kind)) {
+                collectAccessRoot(current.left, reads, true);
+            }
+            collectAssignmentTarget(current.left);
+            collectReadDependencies(current.right);
+            return;
+        }
+        if (ts.isPrefixUnaryExpression(current) || ts.isPostfixUnaryExpression(current)) {
+            if (current.operator === ts.SyntaxKind.PlusPlusToken ||
+                current.operator === ts.SyntaxKind.MinusMinusToken) {
+                collectAccessRoot(current.operand, reads, true);
+                collectAssignmentTarget(current.operand);
+                return;
+            }
+        }
+        if (ts.isVariableDeclaration(current)) {
+            if (current.initializer) {
+                collectReadDependencies(current.initializer);
+            }
+            return;
+        }
+        if (ts.isParameter(current)) {
+            if (current.initializer) {
+                collectReadDependencies(current.initializer);
+            }
+            return;
+        }
+        if (ts.isPropertyAssignment(current)) {
+            collectReadDependencies(current.initializer);
+            return;
+        }
+        if (ts.isShorthandPropertyAssignment(current)) {
+            addBinding(reads, current.name);
+            if (current.objectAssignmentInitializer) {
+                collectReadDependencies(current.objectAssignmentInitializer);
+            }
+            return;
+        }
+        ts.forEachChild(current, collectReadDependencies);
+    }
+    function collectWriteDependencies(node) {
+        const current = unwrapDependencyNode(node);
+        if (ts.isBinaryExpression(current) && isAssignmentOperatorToken(current.operatorToken.kind)) {
+            collectAssignmentTarget(current.left);
+            collectWriteDependencies(current.right);
+            return;
+        }
+        if (ts.isPrefixUnaryExpression(current) || ts.isPostfixUnaryExpression(current)) {
+            if (current.operator === ts.SyntaxKind.PlusPlusToken ||
+                current.operator === ts.SyntaxKind.MinusMinusToken) {
+                collectAssignmentTarget(current.operand);
+                return;
+            }
+        }
+        if (ts.isVariableDeclaration(current)) {
+            if (current.initializer) {
+                collectWriteDependencies(current.initializer);
+            }
+            return;
+        }
+        if (ts.isParameter(current)) {
+            if (current.initializer) {
+                collectWriteDependencies(current.initializer);
+            }
+            return;
+        }
+        ts.forEachChild(current, collectWriteDependencies);
+    }
+    collectReadDependencies(root);
+    collectWriteDependencies(root);
+    return {
+        readSet: reads.build(),
+        writeSet: writes.build(),
+    };
+}
+function normalizeFileNameForComparison(fileName) {
+    return fileName.replaceAll('\\', '/');
+}
+function isCheckedInResultStdlibFile(fileName) {
+    return fileName.endsWith('/src/stdlib/result.d.ts') ||
+        fileName.endsWith('/src/stdlib/result.ts') ||
+        fileName.endsWith('/src/stdlib/index.d.ts') ||
+        fileName.endsWith('/src/stdlib/index.ts');
+}
+function isInstalledResultStdlibFile(fileName) {
+    return fileName.endsWith('/node_modules/@soundscript/soundscript/result.d.ts') ||
+        fileName.endsWith('/node_modules/@soundscript/soundscript/result.js') ||
+        fileName.endsWith('/node_modules/@soundscript/soundscript/index.d.ts') ||
+        fileName.endsWith('/node_modules/@soundscript/soundscript/index.js');
+}
+function isCheckedInErrorStdlibFile(fileName) {
+    return fileName.endsWith('/src/stdlib/failures.d.ts') ||
+        fileName.endsWith('/src/stdlib/failures.ts') ||
+        fileName.endsWith('/src/stdlib/index.d.ts') ||
+        fileName.endsWith('/src/stdlib/index.ts');
+}
+function isInstalledErrorStdlibFile(fileName) {
+    return fileName.endsWith('/node_modules/@soundscript/soundscript/failures.d.ts') ||
+        fileName.endsWith('/node_modules/@soundscript/soundscript/failures.js') ||
+        fileName.endsWith('/node_modules/@soundscript/soundscript/index.d.ts') ||
+        fileName.endsWith('/node_modules/@soundscript/soundscript/index.js');
+}
+function isCheckedInRootStdlibFile(fileName) {
+    return fileName.endsWith('/src/stdlib/index.d.ts') || fileName.endsWith('/src/stdlib/index.ts');
+}
+function isInstalledRootStdlibFile(fileName) {
+    return fileName.endsWith('/node_modules/@soundscript/soundscript/index.d.ts') ||
+        fileName.endsWith('/node_modules/@soundscript/soundscript/index.js');
+}
+function symbolIsOwnedByResultStdlibModule(checker, symbol, exportName) {
+    const resolved = resolveAliasedSymbol(checker, symbol);
+    if (resolved.getName() !== exportName) {
+        return false;
+    }
+    return (resolved.declarations ?? []).some((declaration) => {
+        const fileName = normalizeFileNameForComparison(declaration.getSourceFile().fileName);
+        return fileName === RESULT_STDLIB_DECLARATION_FILE ||
+            fileName === STDLIB_DECLARATION_FILE ||
+            isCheckedInResultStdlibFile(fileName) ||
+            isInstalledResultStdlibFile(fileName) ||
+            isCheckedInRootStdlibFile(fileName) ||
+            isInstalledRootStdlibFile(fileName);
+    });
+}
+function symbolIsOwnedByErrorStdlibModule(checker, symbol, exportName) {
+    const resolved = resolveAliasedSymbol(checker, symbol);
+    if (resolved.getName() !== exportName) {
+        return false;
+    }
+    return (resolved.declarations ?? []).some((declaration) => {
+        const fileName = normalizeFileNameForComparison(declaration.getSourceFile().fileName);
+        return fileName === ERROR_STDLIB_DECLARATION_FILE ||
+            fileName === STDLIB_DECLARATION_FILE ||
+            isCheckedInErrorStdlibFile(fileName) ||
+            isInstalledErrorStdlibFile(fileName);
+    });
+}
+function getBaseTypes(checker, type) {
+    if ((type.flags & ts.TypeFlags.Object) === 0) {
+        return [];
+    }
+    const objectType = type;
+    if ((objectType.objectFlags & (ts.ObjectFlags.Class | ts.ObjectFlags.Interface |
+        ts.ObjectFlags.Reference)) === 0) {
+        return [];
+    }
+    return checker.getBaseTypes(objectType);
+}
+function typeExtendsCanonicalFailure(checker, type, seen = new Set()) {
+    if (seen.has(type)) {
+        return false;
+    }
+    seen.add(type);
+    const symbol = getTypeSymbol(type);
+    if (symbol && symbolIsOwnedByErrorStdlibModule(checker, symbol, 'Failure')) {
+        return true;
+    }
+    if ((type.flags & ts.TypeFlags.Union) !== 0) {
+        return type.types.every((member) => typeExtendsCanonicalFailure(checker, member, seen));
+    }
+    if ((type.flags & ts.TypeFlags.Intersection) !== 0) {
+        return type.types.some((member) => typeExtendsCanonicalFailure(checker, member, seen));
+    }
+    return getBaseTypes(checker, type).some((baseType) => typeExtendsCanonicalFailure(checker, baseType, seen));
+}
+function getTypeArguments(checker, type) {
+    if (type.aliasTypeArguments && type.aliasTypeArguments.length > 0) {
+        return type.aliasTypeArguments;
+    }
+    return checker.getTypeArguments(type);
+}
+function getLiteralCodeForType(checker, type) {
+    if ((type.flags & ts.TypeFlags.StringLiteral) !== 0) {
+        return JSON.stringify(type.value);
+    }
+    if ((type.flags & ts.TypeFlags.NumberLiteral) !== 0) {
+        return String(type.value);
+    }
+    if ((type.flags & ts.TypeFlags.BooleanLiteral) !== 0) {
+        return checker.typeToString(type);
+    }
+    if ((type.flags & ts.TypeFlags.Null) !== 0) {
+        return 'null';
+    }
+    return null;
+}
+function isClassInstanceType(checker, type) {
+    const symbol = getTypeSymbol(type);
+    if (!symbol) {
+        return null;
+    }
+    const resolved = resolveAliasedSymbol(checker, symbol);
+    const declaration = resolved.declarations?.find((candidate) => ts.isClassLike(candidate));
+    if (!declaration) {
+        return null;
+    }
+    return resolved.getName();
+}
+function builtinRuntimeConstructorName(checker, type) {
+    const displayText = checker.typeToString(type);
+    const baseName = displayText.match(/^[A-Za-z_$][A-Za-z0-9_$]*/)?.[0] ?? null;
+    if (!baseName || !BUILTIN_RUNTIME_CONSTRUCTOR_NAMES.has(baseName)) {
+        return null;
+    }
+    return baseName;
+}
+function combineFiniteCaseOptions(optionSets) {
+    let combinations = [[]];
+    for (const optionSet of optionSets) {
+        const next = [];
+        for (const combination of combinations) {
+            for (const option of optionSet) {
+                next.push([...combination, option]);
+                if (next.length > MAX_FINITE_CASE_COMBINATIONS) {
+                    return null;
+                }
+            }
+        }
+        combinations = next;
+    }
+    return combinations;
+}
+function getSingleFiniteTupleCase(checker, type, visiting) {
+    if (!checker.isTupleType(type) || (type.flags & ts.TypeFlags.Object) === 0) {
+        return null;
+    }
+    const tupleType = type;
+    const tupleTarget = tupleType.target;
+    if ((tupleTarget.combinedFlags & ts.ElementFlags.Variable) ||
+        tupleTarget.minLength !== tupleTarget.fixedLength) {
+        return null;
+    }
+    if (visiting.has(type)) {
+        return null;
+    }
+    visiting.add(type);
+    try {
+        const elements = checker.getTypeArguments(tupleType).map((elementType) => ({
+            finiteCase: getSingleFiniteCaseForTsType(checker, elementType, visiting),
+        }));
+        return {
+            elements,
+            exactLength: tupleTarget.fixedLength,
+            kind: 'array',
+        };
+    }
+    finally {
+        visiting.delete(type);
+    }
+}
+function getFiniteTupleCases(checker, type, visiting) {
+    if (!checker.isTupleType(type) || (type.flags & ts.TypeFlags.Object) === 0) {
+        return null;
+    }
+    const tupleType = type;
+    const tupleTarget = tupleType.target;
+    if (tupleTarget.combinedFlags & ts.ElementFlags.Variable) {
+        return null;
+    }
+    if (visiting.has(type)) {
+        return null;
+    }
+    visiting.add(type);
+    try {
+        const elementTypes = checker.getTypeArguments(tupleType);
+        const finiteCases = [];
+        for (let length = tupleTarget.minLength; length <= tupleTarget.fixedLength; length += 1) {
+            const elementOptions = elementTypes
+                .slice(0, length)
+                .map((elementType) => getFiniteCasesForTsTypeInternal(checker, elementType, visiting) ?? [null]);
+            const elementCombinations = combineFiniteCaseOptions(elementOptions);
+            if (!elementCombinations) {
+                return null;
+            }
+            for (const elementCombination of elementCombinations) {
+                finiteCases.push({
+                    elements: elementCombination.map((finiteCase) => ({ finiteCase })),
+                    exactLength: length,
+                    kind: 'array',
+                });
+            }
+        }
+        return finiteCases;
+    }
+    finally {
+        visiting.delete(type);
+    }
+}
+function getFiniteObjectCases(checker, type, visiting) {
+    if (visiting.has(type)) {
+        return null;
+    }
+    visiting.add(type);
+    try {
+        const properties = checker.getPropertiesOfType(type);
+        if (properties.length === 0) {
+            return null;
+        }
+        const propertyOptions = [];
+        const propertyKeys = [];
+        let hasFiniteDetail = false;
+        for (const property of properties) {
+            if ((property.flags & ts.SymbolFlags.Optional) !== 0) {
+                return null;
+            }
+            const declaration = property.valueDeclaration ?? property.declarations?.[0];
+            if (!declaration) {
+                propertyKeys.push(property.getName());
+                propertyOptions.push([null]);
+                continue;
+            }
+            const propertyType = checker.getTypeOfSymbolAtLocation(property, declaration);
+            const finiteCases = getFiniteCasesForTsTypeInternal(checker, propertyType, visiting);
+            if (finiteCases !== null) {
+                hasFiniteDetail = true;
+            }
+            propertyKeys.push(property.getName());
+            propertyOptions.push(finiteCases ?? [null]);
+        }
+        if (!hasFiniteDetail) {
+            return null;
+        }
+        const propertyCombinations = combineFiniteCaseOptions(propertyOptions);
+        if (!propertyCombinations) {
+            return null;
+        }
+        return propertyCombinations.map((propertyCombination) => ({
+            kind: 'object',
+            properties: propertyCombination.map((finiteCase, index) => ({
+                finiteCase,
+                key: propertyKeys[index],
+            })),
+        }));
+    }
+    finally {
+        visiting.delete(type);
+    }
+}
+function getRuntimeKindFiniteCase(checker, type) {
+    const runtimeKind = getRuntimeKindForTsType(checker, type);
+    return runtimeKind ? { kind: 'runtime', typeName: runtimeKind } : null;
+}
+function getRuntimeKindForTsType(checker, type) {
+    const aliasName = type.aliasSymbol?.getName();
+    if (aliasName === 'f64' ||
+        aliasName === 'f32' ||
+        aliasName === 'i8' ||
+        aliasName === 'i16' ||
+        aliasName === 'i32' ||
+        aliasName === 'i64' ||
+        aliasName === 'u8' ||
+        aliasName === 'u16' ||
+        aliasName === 'u32' ||
+        aliasName === 'u64') {
+        return aliasName;
+    }
+    if ((type.flags & (ts.TypeFlags.Undefined | ts.TypeFlags.Void)) !== 0) {
+        return 'undefined';
+    }
+    if ((type.flags & ts.TypeFlags.StringLike) !== 0) {
+        return 'string';
+    }
+    if ((type.flags & ts.TypeFlags.NumberLike) !== 0) {
+        return 'number';
+    }
+    if ((type.flags & ts.TypeFlags.BigIntLike) !== 0) {
+        return 'bigint';
+    }
+    if ((type.flags & ts.TypeFlags.ESSymbolLike) !== 0) {
+        return 'symbol';
+    }
+    if (checker.getSignaturesOfType(type, ts.SignatureKind.Call).length > 0) {
+        return 'function';
+    }
+    if ((type.flags & (ts.TypeFlags.Object | ts.TypeFlags.NonPrimitive)) !== 0) {
+        return 'object';
+    }
+    return null;
+}
+function getSingleFiniteCaseForTsType(checker, type, visiting = new Set()) {
+    const literalCode = getLiteralCodeForType(checker, type);
+    if (literalCode !== null) {
+        return { kind: 'literal', code: literalCode };
+    }
+    const className = isClassInstanceType(checker, type);
+    if (className) {
+        return { kind: 'class', className };
+    }
+    const builtinClassName = builtinRuntimeConstructorName(checker, type);
+    if (builtinClassName) {
+        return { kind: 'class', className: builtinClassName };
+    }
+    return getSingleFiniteTupleCase(checker, type, visiting) ??
+        getRuntimeKindFiniteCase(checker, type);
+}
+function getFiniteCasesForTsTypeInternal(checker, type, visiting) {
+    if ((type.flags & ts.TypeFlags.Boolean) !== 0) {
+        return [
+            { kind: 'literal', code: 'true' },
+            { kind: 'literal', code: 'false' },
+        ];
+    }
+    if (type.isUnion()) {
+        const finiteCases = [];
+        for (const member of type.types) {
+            const memberCases = getFiniteCasesForTsTypeInternal(checker, member, visiting);
+            if (!memberCases) {
+                return null;
+            }
+            finiteCases.push(...memberCases);
+            if (finiteCases.length > MAX_FINITE_CASE_COMBINATIONS) {
+                return null;
+            }
+        }
+        return finiteCases;
+    }
+    const baseFiniteCase = getSingleFiniteCaseForTsType(checker, type, visiting);
+    if (baseFiniteCase?.kind === 'literal' || baseFiniteCase?.kind === 'class') {
+        return [baseFiniteCase];
+    }
+    if (baseFiniteCase?.kind === 'runtime' && baseFiniteCase.typeName !== 'object') {
+        return [baseFiniteCase];
+    }
+    const tupleCases = getFiniteTupleCases(checker, type, visiting);
+    if (tupleCases) {
+        return tupleCases;
+    }
+    const objectCases = getFiniteObjectCases(checker, type, visiting);
+    if (objectCases) {
+        return objectCases;
+    }
+    return baseFiniteCase ? [baseFiniteCase] : null;
+}
+function getFiniteCasesForTsType(checker, type) {
+    return getFiniteCasesForTsTypeInternal(checker, type, new Set());
+}
+function classifyCanonicalResultTsType(checker, tsType) {
+    const symbol = getTypeSymbol(tsType);
+    if (!symbol) {
+        return null;
+    }
+    if (symbolIsOwnedByResultStdlibModule(checker, symbol, 'Result')) {
+        const typeArguments = getTypeArguments(checker, tsType);
+        if (typeArguments.length !== 2) {
+            return null;
+        }
+        const [okType, errType] = typeArguments;
+        return {
+            errType: createMacroType(checker, errType),
+            family: 'result',
+            okType: createMacroType(checker, okType),
+            resultType: createMacroType(checker, tsType),
+        };
+    }
+    if (symbolIsOwnedByResultStdlibModule(checker, symbol, 'Option')) {
+        const typeArguments = getTypeArguments(checker, tsType);
+        if (typeArguments.length !== 1) {
+            return null;
+        }
+        const [okType] = typeArguments;
+        const voidType = checker.getVoidType();
+        return {
+            errType: createMacroType(checker, voidType),
+            family: 'option',
+            okType: createMacroType(checker, okType),
+            resultType: createMacroType(checker, tsType),
+        };
+    }
+    return null;
+}
+function classifyCanonicalPromiseResultTsType(checker, tsType) {
+    const symbol = getTypeSymbol(tsType);
+    if (!symbol || resolveAliasedSymbol(checker, symbol).getName() !== 'Promise') {
+        return null;
+    }
+    const [promisedType] = getTypeArguments(checker, tsType);
+    return promisedType ? classifyCanonicalResultTsType(checker, promisedType) : null;
+}
+function mergeInferredResultSideTypes(checker, current, next) {
+    if ((current.flags & ts.TypeFlags.Never) !== 0) {
+        return next;
+    }
+    if ((next.flags & ts.TypeFlags.Never) !== 0) {
+        return current;
+    }
+    if (checker.isTypeAssignableTo(next, current)) {
+        return current;
+    }
+    if (checker.isTypeAssignableTo(current, next)) {
+        return next;
+    }
+    return null;
+}
+function inferCanonicalResultTsTypeFromFunctionReturns(checker, node) {
+    if (!ts.isFunctionLike(node) ||
+        node.kind === ts.SyntaxKind.Constructor) {
+        return null;
+    }
+    if (ts.isArrowFunction(node) && !ts.isBlock(node.body)) {
+        return classifyCanonicalResultTsType(checker, checker.getTypeAtLocation(node.body));
+    }
+    const body = 'body' in node ? node.body : undefined;
+    if (!body || !ts.isBlock(body)) {
+        return null;
+    }
+    let inferred = null;
+    let sawReturn = false;
+    let failed = false;
+    function visit(current) {
+        if (failed) {
+            return;
+        }
+        if (ts.isFunctionLike(current) && current !== node) {
+            return;
+        }
+        if (ts.isReturnStatement(current)) {
+            sawReturn = true;
+            if (!current.expression) {
+                failed = true;
+                return;
+            }
+            const info = classifyCanonicalResultTsType(checker, checker.getTypeAtLocation(current.expression));
+            if (!info) {
+                failed = true;
+                return;
+            }
+            if (!inferred) {
+                inferred = info;
+                return;
+            }
+            if (inferred.family !== info.family) {
+                failed = true;
+                return;
+            }
+            const mergedOkType = mergeInferredResultSideTypes(checker, getInternalType(inferred.okType), getInternalType(info.okType));
+            const mergedErrType = mergeInferredResultSideTypes(checker, getInternalType(inferred.errType), getInternalType(info.errType));
+            if (!mergedOkType || !mergedErrType) {
+                failed = true;
+                return;
+            }
+            inferred = {
+                errType: createMacroType(checker, mergedErrType),
+                family: inferred.family,
+                okType: createMacroType(checker, mergedOkType),
+                resultType: inferred.resultType,
+            };
+            return;
+        }
+        ts.forEachChild(current, visit);
+    }
+    visit(body);
+    return failed || !sawReturn ? null : inferred;
+}
+function classifyEffectiveFunctionResultTsType(checker, node) {
+    if (!ts.isFunctionLike(node) ||
+        node.kind === ts.SyntaxKind.Constructor) {
+        return null;
+    }
+    const returnType = getFunctionReturnType(checker, node);
+    if (returnType) {
+        const signatureResult = isAsyncFunctionLike(node)
+            ? classifyCanonicalPromiseResultTsType(checker, returnType)
+            : classifyCanonicalResultTsType(checker, returnType);
+        if (signatureResult || node.type) {
+            return signatureResult;
+        }
+    }
+    return inferCanonicalResultTsTypeFromFunctionReturns(checker, node);
+}
+function classifyTryCarrierTsType(checker, tsType) {
+    const resultInfo = classifyCanonicalResultTsType(checker, tsType);
+    if (resultInfo) {
+        return {
+            ...resultInfo,
+            kind: 'result',
+        };
+    }
+    const hasNull = checker.isTypeAssignableTo(checker.getNullType(), tsType);
+    const hasUndefined = checker.isTypeAssignableTo(checker.getUndefinedType(), tsType);
+    if (!hasNull && !hasUndefined) {
+        return null;
+    }
+    const valueType = checker.getNonNullableType(tsType);
+    if ((valueType.flags & ts.TypeFlags.Never) !== 0) {
+        return null;
+    }
+    if (valueType === tsType) {
+        return null;
+    }
+    return {
+        carrierType: createMacroType(checker, tsType),
+        kind: 'nullish',
+        nullishKinds: [
+            ...(hasNull ? ['null'] : []),
+            ...(hasUndefined ? ['undefined'] : []),
+        ],
+        valueType: createMacroType(checker, valueType),
+    };
+}
+export function createMacroSemantics(program) {
+    const checker = program.getTypeChecker();
+    return {
+        awaitedType(type) {
+            const typeChecker = getInternalChecker(type);
+            const tsType = getInternalType(type);
+            return createMacroType(typeChecker, typeChecker.getAwaitedType(tsType) ?? tsType);
+        },
+        classDeclarationOfTypeNode(node) {
+            return resolveClassDeclarationForTypeNode(checker, node);
+        },
+        canonicalResultOfEnclosingFunctionNode(node) {
+            let current = node;
+            while (current) {
+                if (ts.isFunctionLike(current) && current.kind !== ts.SyntaxKind.Constructor) {
+                    return classifyEffectiveFunctionResultTsType(checker, current) ?? undefined;
+                }
+                current = current.parent;
+            }
+            return undefined;
+        },
+        classifyCanonicalFailureType(type) {
+            const tsType = getInternalType(type);
+            if (!typeExtendsCanonicalFailure(checker, tsType)) {
+                return null;
+            }
+            return {
+                failureType: createMacroType(getInternalChecker(type), tsType),
+            };
+        },
+        classifyCanonicalResultCarrierType(type) {
+            const typeChecker = getInternalChecker(type);
+            const tsType = getInternalType(type);
+            const directResult = classifyCanonicalResultTsType(typeChecker, tsType);
+            if (directResult) {
+                return {
+                    ...directResult,
+                    requiresAwait: false,
+                };
+            }
+            const awaitedType = typeChecker.getAwaitedType(tsType);
+            if (!awaitedType || awaitedType === tsType) {
+                const promisedResult = classifyCanonicalPromiseResultTsType(typeChecker, tsType);
+                return promisedResult
+                    ? {
+                        ...promisedResult,
+                        requiresAwait: true,
+                    }
+                    : null;
+            }
+            const awaitedResult = classifyCanonicalResultTsType(typeChecker, awaitedType);
+            if (!awaitedResult) {
+                const promisedResult = classifyCanonicalPromiseResultTsType(typeChecker, tsType);
+                return promisedResult
+                    ? {
+                        ...promisedResult,
+                        requiresAwait: true,
+                    }
+                    : null;
+            }
+            return {
+                ...awaitedResult,
+                requiresAwait: true,
+            };
+        },
+        classifyCanonicalResultType(type) {
+            return classifyCanonicalResultTsType(getInternalChecker(type), getInternalType(type));
+        },
+        classifyTryCarrierType(type) {
+            return classifyTryCarrierTsType(getInternalChecker(type), getInternalType(type));
+        },
+        finiteCases(type) {
+            return getFiniteCasesForTsType(getInternalChecker(type), getInternalType(type));
+        },
+        enclosingFunctionOfNode(node) {
+            let current = node;
+            while (current) {
+                if (ts.isFunctionLike(current) && current.kind !== ts.SyntaxKind.Constructor) {
+                    const returnType = getFunctionReturnType(checker, current);
+                    if (!returnType) {
+                        return undefined;
+                    }
+                    return {
+                        fileName: toSourceFileName(current.getSourceFile().fileName),
+                        hasDeclaredReturnType: current.type !== undefined,
+                        isAsync: isAsyncFunctionLike(current),
+                        isGenerator: isGeneratorFunctionLike(current),
+                        name: getFunctionLikeName(current),
+                        returnType: createMacroType(checker, returnType),
+                        span: createSourceSpan(current),
+                    };
+                }
+                current = current.parent;
+            }
+            return undefined;
+        },
+        isAssignable(from, to) {
+            const fromChecker = getInternalChecker(from);
+            const toChecker = getInternalChecker(to);
+            if (fromChecker === toChecker) {
+                return fromChecker.isTypeAssignableTo(getInternalType(from), getInternalType(to));
+            }
+            return checker.isTypeAssignableTo(getInternalType(from), getInternalType(to));
+        },
+        nullType() {
+            return createMacroType(checker, checker.getNullType());
+        },
+        readSetOfNode(node) {
+            return collectDependencySets(checker, node).readSet;
+        },
+        typeOfNode(node) {
+            return createMacroType(checker, getNodeType(checker, node));
+        },
+        undefinedType() {
+            return createMacroType(checker, checker.getUndefinedType());
+        },
+        valueBindingCallableInScope(name, node) {
+            const binding = getValuePathBindingInScope(checker, node, name);
+            if (!binding) {
+                return false;
+            }
+            return checker.getSignaturesOfType(binding.type, ts.SignatureKind.Call).length > 0 ||
+                (binding.fromAlias && (binding.type.flags & ts.TypeFlags.Any) !== 0) ||
+                (binding.symbol.declarations ?? []).some(declarationIsCallable);
+        },
+        valueBindingInScope(name, node) {
+            return getValuePathBindingInScope(checker, node, name) !== null;
+        },
+        writeSetOfNode(node) {
+            return collectDependencySets(checker, node).writeSet;
+        },
+    };
+}