@soundscript/soundscript 0.1.12 → 0.1.15

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

@@ -0,0 +1,69 @@
+import ts from 'typescript';
+import { mapProgramRangeToSource, } from './project_frontend.js';
+function getPlaceholderId(callExpression) {
+    if (callExpression.arguments.length !== 1) {
+        return undefined;
+    }
+    const [firstArgument] = callExpression.arguments;
+    return ts.isNumericLiteral(firstArgument) ? Number(firstArgument.text) : undefined;
+}
+function isMacroPlaceholderName(text) {
+    return text === '__sts_macro_expr' || text === '__sts_macro_stmt';
+}
+function matchesIndexedPlaceholderSpan(sourceFile, callExpression, placeholder, preparedFile) {
+    if (preparedFile) {
+        const mappedRange = mapProgramRangeToSource(preparedFile, callExpression.getStart(sourceFile), callExpression.getEnd());
+        return mappedRange.start === placeholder.replacement.originalSpan.start &&
+            mappedRange.end <= placeholder.replacement.originalSpan.end;
+    }
+    return callExpression.getStart(sourceFile) === placeholder.replacement.rewrittenSpan.start &&
+        callExpression.getEnd() <= placeholder.replacement.rewrittenSpan.end;
+}
+export function resolveMacroPlaceholdersInSourceFile(sourceFile, placeholderIndex, preparedFile) {
+    const resolved = [];
+    function visit(node) {
+        if (ts.isCallExpression(node) && ts.isIdentifier(node.expression)) {
+            if (isMacroPlaceholderName(node.expression.text)) {
+                const id = getPlaceholderId(node);
+                if (id !== undefined) {
+                    const placeholder = placeholderIndex.get(sourceFile.fileName, id);
+                    if (placeholder && matchesIndexedPlaceholderSpan(sourceFile, node, placeholder, preparedFile)) {
+                        resolved.push({
+                            callExpression: node,
+                            placeholder,
+                        });
+                    }
+                }
+            }
+        }
+        ts.forEachChild(node, visit);
+    }
+    visit(sourceFile);
+    return resolved;
+}
+export function collectResolvedMacroPlaceholders(preparedProgram) {
+    const placeholderIndex = preparedProgram.placeholderIndex();
+    const collected = preparedProgram.program.getSourceFiles()
+        .filter((sourceFile) => !sourceFile.isDeclarationFile)
+        .flatMap((sourceFile) => {
+        const sourceFileName = preparedProgram.toSourceFileName(sourceFile.fileName);
+        const preparedFile = preparedProgram.preparedHost?.getPreparedSourceFile(sourceFileName);
+        return resolveMacroPlaceholdersInSourceFile(sourceFile, {
+            entries: placeholderIndex.entries,
+            get(fileName, id) {
+                return placeholderIndex.get(preparedProgram.toSourceFileName(fileName), id);
+            },
+        }, preparedFile).map((resolved) => ({
+            resolved,
+            sourceFile,
+        }));
+    });
+    collected.sort((left, right) => {
+        if (left.sourceFile.fileName !== right.sourceFile.fileName) {
+            return left.sourceFile.fileName.localeCompare(right.sourceFile.fileName);
+        }
+        return left.resolved.callExpression.getStart(left.sourceFile) -
+            right.resolved.callExpression.getStart(right.sourceFile);
+    });
+    return collected;
+}

package/project-transform/src/frontend/macro_resolver.ts

@@ -0,0 +1,125 @@
+import ts from 'typescript';
+
+import type { IndexedMacroPlaceholder, MacroPlaceholderIndex } from './macro_index.ts';
+import {
+  mapProgramRangeToSource,
+  type PreparedCompilerHost,
+  type PreparedProgram,
+  type PreparedSourceFile,
+} from './project_frontend.ts';
+
+export interface ResolvedMacroPlaceholder {
+  callExpression: ts.CallExpression;
+  placeholder: IndexedMacroPlaceholder;
+}
+
+export interface CollectedResolvedMacroPlaceholder {
+  resolved: ResolvedMacroPlaceholder;
+  sourceFile: ts.SourceFile;
+}
+
+type MacroResolverPreparedProgram = Pick<
+  PreparedProgram,
+  'placeholderIndex' | 'program' | 'toSourceFileName'
+> & {
+  preparedHost?: Pick<PreparedCompilerHost, 'getPreparedSourceFile'>;
+};
+
+function getPlaceholderId(callExpression: ts.CallExpression): number | undefined {
+  if (callExpression.arguments.length !== 1) {
+    return undefined;
+  }
+
+  const [firstArgument] = callExpression.arguments;
+  return ts.isNumericLiteral(firstArgument) ? Number(firstArgument.text) : undefined;
+}
+
+function isMacroPlaceholderName(text: string): boolean {
+  return text === '__sts_macro_expr' || text === '__sts_macro_stmt';
+}
+
+function matchesIndexedPlaceholderSpan(
+  sourceFile: ts.SourceFile,
+  callExpression: ts.CallExpression,
+  placeholder: IndexedMacroPlaceholder,
+  preparedFile?: PreparedSourceFile,
+): boolean {
+  if (preparedFile) {
+    const mappedRange = mapProgramRangeToSource(
+      preparedFile,
+      callExpression.getStart(sourceFile),
+      callExpression.getEnd(),
+    );
+    return mappedRange.start === placeholder.replacement.originalSpan.start &&
+      mappedRange.end <= placeholder.replacement.originalSpan.end;
+  }
+
+  return callExpression.getStart(sourceFile) === placeholder.replacement.rewrittenSpan.start &&
+    callExpression.getEnd() <= placeholder.replacement.rewrittenSpan.end;
+}
+
+export function resolveMacroPlaceholdersInSourceFile(
+  sourceFile: ts.SourceFile,
+  placeholderIndex: MacroPlaceholderIndex,
+  preparedFile?: PreparedSourceFile,
+): ResolvedMacroPlaceholder[] {
+  const resolved: ResolvedMacroPlaceholder[] = [];
+
+  function visit(node: ts.Node) {
+    if (ts.isCallExpression(node) && ts.isIdentifier(node.expression)) {
+      if (isMacroPlaceholderName(node.expression.text)) {
+        const id = getPlaceholderId(node);
+        if (id !== undefined) {
+          const placeholder = placeholderIndex.get(sourceFile.fileName, id);
+          if (placeholder && matchesIndexedPlaceholderSpan(sourceFile, node, placeholder, preparedFile)) {
+            resolved.push({
+              callExpression: node,
+              placeholder,
+            });
+          }
+        }
+      }
+    }
+
+    ts.forEachChild(node, visit);
+  }
+
+  visit(sourceFile);
+  return resolved;
+}
+
+export function collectResolvedMacroPlaceholders(
+  preparedProgram: MacroResolverPreparedProgram,
+): CollectedResolvedMacroPlaceholder[] {
+  const placeholderIndex = preparedProgram.placeholderIndex();
+  const collected = preparedProgram.program.getSourceFiles()
+    .filter((sourceFile) => !sourceFile.isDeclarationFile)
+    .flatMap((sourceFile) => {
+      const sourceFileName = preparedProgram.toSourceFileName(sourceFile.fileName);
+      const preparedFile = preparedProgram.preparedHost?.getPreparedSourceFile(sourceFileName);
+      return resolveMacroPlaceholdersInSourceFile(
+        sourceFile,
+        {
+          entries: placeholderIndex.entries,
+          get(fileName: string, id: number) {
+            return placeholderIndex.get(preparedProgram.toSourceFileName(fileName), id);
+          },
+        },
+        preparedFile,
+        ).map((resolved) => ({
+          resolved,
+          sourceFile,
+        }));
+    });
+
+  collected.sort((left, right) => {
+    if (left.sourceFile.fileName !== right.sourceFile.fileName) {
+      return left.sourceFile.fileName.localeCompare(right.sourceFile.fileName);
+    }
+
+    return left.resolved.callExpression.getStart(left.sourceFile) -
+      right.resolved.callExpression.getStart(right.sourceFile);
+  });
+
+  return collected;
+}

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

@@ -0,0 +1,285 @@
+import ts from 'typescript';
+import { BUILTIN_DIRECTIVE_NAMES, createAnnotationLookup } from '../annotation_syntax.js';
+import { scanMacroCandidates } from './macro_scanner.js';
+function createSpan(fileName, start, end) {
+    return { fileName, start, end };
+}
+function createPlaceholder(id, rewriteKind) {
+    return rewriteKind === 'expr' ? `__sts_macro_expr(${id})` : `__sts_macro_stmt(${id});`;
+}
+function scriptKindForFile(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 collectImportedMacroBindings(sourceFile, importedMacroSiteKindsBySpecifier) {
+    const callNames = new Set();
+    const tagNames = new Set();
+    const annotationNames = new Set();
+    for (const statement of sourceFile.statements) {
+        if (!ts.isImportDeclaration(statement)) {
+            continue;
+        }
+        const explicitKinds = ts.isStringLiteral(statement.moduleSpecifier)
+            ? importedMacroSiteKindsBySpecifier.get(statement.moduleSpecifier.text)
+            : undefined;
+        if (!explicitKinds) {
+            continue;
+        }
+        if (statement.importClause?.name) {
+            const localName = statement.importClause.name.text;
+            const explicitKind = explicitKinds.get('default');
+            if (explicitKind === 'annotation' && !BUILTIN_DIRECTIVE_NAMES.has(localName)) {
+                annotationNames.add(localName);
+            }
+            else if (explicitKind === 'call') {
+                callNames.add(localName);
+            }
+            else if (explicitKind === 'tag') {
+                tagNames.add(localName);
+            }
+        }
+        const namedBindings = statement.importClause?.namedBindings;
+        if (!namedBindings || !ts.isNamedImports(namedBindings)) {
+            continue;
+        }
+        for (const element of namedBindings.elements) {
+            const localName = element.name.text;
+            const exportName = element.propertyName?.text ?? localName;
+            const explicitKind = explicitKinds?.get(exportName);
+            if (explicitKind === 'annotation' && !BUILTIN_DIRECTIVE_NAMES.has(localName)) {
+                annotationNames.add(localName);
+                continue;
+            }
+            if (explicitKind === 'call') {
+                callNames.add(localName);
+                continue;
+            }
+            if (explicitKind === 'tag') {
+                tagNames.add(localName);
+                continue;
+            }
+        }
+    }
+    return { annotationNames, callNames, tagNames };
+}
+function parentExpressionStatement(node) {
+    return ts.isExpressionStatement(node.parent) && node.parent.expression === node
+        ? node.parent
+        : null;
+}
+function getRewriteKindForCall(node) {
+    return parentExpressionStatement(node) ? 'stmt' : 'expr';
+}
+function createCallSite(sourceFile, node) {
+    const statement = parentExpressionStatement(node);
+    return {
+        kind: 'call',
+        argumentSpans: node.arguments.map((argument) => ({
+            kind: 'ExprArg',
+            span: createSpan(sourceFile.fileName, argument.getStart(sourceFile), argument.getEnd()),
+        })),
+        invocationKind: 'arglist',
+        nameSpan: createSpan(sourceFile.fileName, node.expression.getStart(sourceFile), node.expression.getEnd()),
+        nameText: node.expression.text,
+        replacementSpan: createSpan(sourceFile.fileName, statement?.getStart(sourceFile) ?? node.getStart(sourceFile), statement?.getEnd() ?? node.getEnd()),
+        span: createSpan(sourceFile.fileName, node.getStart(sourceFile), node.getEnd()),
+        rewriteKind: getRewriteKindForCall(node),
+    };
+}
+function createTagSite(sourceFile, node) {
+    return {
+        kind: 'tag',
+        argumentSpans: [{
+                kind: 'ExprArg',
+                span: createSpan(sourceFile.fileName, node.template.getStart(sourceFile), node.template.getEnd()),
+            }],
+        invocationKind: 'arglist',
+        nameSpan: createSpan(sourceFile.fileName, node.tag.getStart(sourceFile), node.tag.getEnd()),
+        nameText: node.tag.text,
+        replacementSpan: createSpan(sourceFile.fileName, node.getStart(sourceFile), node.getEnd()),
+        span: createSpan(sourceFile.fileName, node.getStart(sourceFile), node.getEnd()),
+        rewriteKind: 'expr',
+    };
+}
+function isMacroDeclarationTarget(node) {
+    return ts.isClassDeclaration(node) || ts.isFunctionDeclaration(node) ||
+        ts.isInterfaceDeclaration(node) || ts.isTypeAliasDeclaration(node);
+}
+function findAnnotationSites(annotationLookup, sourceFile, node, annotationNames) {
+    if (annotationNames.size === 0) {
+        return [];
+    }
+    const block = annotationLookup.getAttachedAnnotationBlock(node);
+    const matchedAnnotations = block?.annotations.filter((annotation) => annotation.nameRange && annotationNames.has(annotation.name)) ?? [];
+    if (!block || matchedAnnotations.length === 0) {
+        return [];
+    }
+    const nodeStart = node.getStart(sourceFile);
+    const declarationKind = ts.isClassDeclaration(node)
+        ? 'class'
+        : ts.isFunctionDeclaration(node)
+            ? 'function'
+            : ts.isInterfaceDeclaration(node)
+                ? 'interface'
+                : 'typeAlias';
+    return matchedAnnotations.map((annotation, index) => ({
+        kind: 'annotation',
+        argumentSpans: [],
+        declarationKind,
+        declarationName: node.name?.text ?? null,
+        declarationSpan: createSpan(sourceFile.fileName, nodeStart, node.getEnd()),
+        invocationKind: 'decl',
+        nameSpan: createSpan(sourceFile.fileName, annotation.nameRange.start, annotation.nameRange.end),
+        nameText: annotation.name,
+        preserveDeclaration: index === 0,
+        replacementSpan: createSpan(sourceFile.fileName, block.range.start, node.getEnd()),
+        span: createSpan(sourceFile.fileName, block.range.start, node.getEnd()),
+        rewriteKind: 'stmt',
+    }));
+}
+function collectMacroSites(sourceFile, importedMacroSiteKindsBySpecifier, alwaysAvailableMacroSiteKinds) {
+    const bindings = collectImportedMacroBindings(sourceFile, importedMacroSiteKindsBySpecifier);
+    const annotationLookup = createAnnotationLookup(sourceFile);
+    for (const [name, kind] of alwaysAvailableMacroSiteKinds.entries()) {
+        if (kind === 'annotation') {
+            bindings.annotationNames.add(name);
+            continue;
+        }
+        if (kind === 'call') {
+            bindings.callNames.add(name);
+            continue;
+        }
+        bindings.tagNames.add(name);
+    }
+    const sites = [];
+    for (const statement of sourceFile.statements) {
+        if (!isMacroDeclarationTarget(statement)) {
+            continue;
+        }
+        const annotationSites = findAnnotationSites(annotationLookup, sourceFile, statement, bindings.annotationNames);
+        sites.push(...annotationSites);
+    }
+    const visit = (node) => {
+        if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) &&
+            bindings.callNames.has(node.expression.text)) {
+            sites.push(createCallSite(sourceFile, node));
+            return;
+        }
+        if (ts.isTaggedTemplateExpression(node) &&
+            ts.isIdentifier(node.tag) &&
+            bindings.tagNames.has(node.tag.text)) {
+            sites.push(createTagSite(sourceFile, node));
+            return;
+        }
+        ts.forEachChild(node, visit);
+    };
+    ts.forEachChild(sourceFile, visit);
+    sites.sort((left, right) => left.replacementSpan.start - right.replacementSpan.start);
+    const filtered = [];
+    let currentEnd = -1;
+    let currentStart = -1;
+    for (const site of sites) {
+        const sameReplacementSpan = site.replacementSpan.start === currentStart &&
+            site.replacementSpan.end === currentEnd;
+        if (site.replacementSpan.start < currentEnd && !sameReplacementSpan) {
+            continue;
+        }
+        filtered.push(site);
+        currentStart = site.replacementSpan.start;
+        currentEnd = site.replacementSpan.end;
+    }
+    return filtered;
+}
+function createLegacySyntaxDiagnostic(fileName, start, end) {
+    return {
+        fileName,
+        reason: 'legacy-syntax',
+        span: createSpan(fileName, start, end),
+    };
+}
+function toParsedInvocation(site) {
+    return {
+        argumentSpans: site.argumentSpans,
+        declarationKind: site.kind === 'annotation' ? site.declarationKind : undefined,
+        declarationName: site.kind === 'annotation' ? site.declarationName : undefined,
+        preserveDeclaration: site.kind === 'annotation' ? site.preserveDeclaration : undefined,
+        declarationSpan: site.kind === 'annotation' ? site.declarationSpan : undefined,
+        fileName: site.span.fileName,
+        hashSpan: site.nameSpan,
+        nameSpan: site.nameSpan,
+        nameText: site.nameText,
+        siteKind: site.kind,
+        span: site.span,
+        trailingBlockSpan: undefined,
+        invocationKind: site.invocationKind,
+        rewriteKind: site.rewriteKind,
+    };
+}
+function buildRewriteResult(text, sites) {
+    const replacements = [];
+    const generatedSpans = [];
+    const macrosById = new Map();
+    let rewrittenText = '';
+    let cursor = 0;
+    let nextId = 1;
+    for (const site of sites) {
+        const id = nextId;
+        nextId += 1;
+        const placeholder = createPlaceholder(id, site.rewriteKind);
+        rewrittenText += text.slice(cursor, site.replacementSpan.start);
+        const generatedStart = rewrittenText.length;
+        rewrittenText += placeholder;
+        const generatedEnd = rewrittenText.length;
+        cursor = site.replacementSpan.end;
+        const rewrittenSpan = {
+            fileName: site.span.fileName,
+            start: generatedStart,
+            end: generatedEnd,
+        };
+        replacements.push({
+            id,
+            originalSpan: site.replacementSpan,
+            rewriteText: placeholder,
+            rewrittenSpan,
+        });
+        generatedSpans.push({
+            generatedEnd,
+            generatedFileName: site.span.fileName,
+            generatedStart,
+            id,
+            originalSpan: site.replacementSpan,
+        });
+        macrosById.set(id, toParsedInvocation(site));
+    }
+    rewrittenText += text.slice(cursor);
+    return {
+        diagnostics: [],
+        generatedSpans,
+        macrosById,
+        replacements,
+        rewrittenText,
+    };
+}
+export function rewriteMacroSource(fileName, text, importedMacroSiteKindsBySpecifier = new Map(), alwaysAvailableMacroSiteKinds = new Map()) {
+    const legacyHashes = scanMacroCandidates(fileName, text).hashes.filter((hash) => hash.kind === 'macro-start');
+    if (legacyHashes.length > 0) {
+        const firstLegacyHash = legacyHashes[0];
+        return {
+            diagnostics: [
+                createLegacySyntaxDiagnostic(fileName, firstLegacyHash.span.start, firstLegacyHash.span.end),
+            ],
+            generatedSpans: [],
+            macrosById: new Map(),
+            replacements: [],
+            rewrittenText: text,
+        };
+    }
+    const sourceFile = ts.createSourceFile(fileName, text, ts.ScriptTarget.Latest, true, scriptKindForFile(fileName));
+    return buildRewriteResult(text, collectMacroSites(sourceFile, importedMacroSiteKindsBySpecifier, alwaysAvailableMacroSiteKinds));
+}