@soundscript/soundscript 0.1.12 → 0.1.15

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

@@ -0,0 +1,297 @@
+import ts from 'typescript';
+import { getAlwaysAvailableBuiltinMacroDefinitions, getAlwaysAvailableBuiltinMacroSiteKinds, getBuiltinMacroDefinitionsBySpecifier, getBuiltinMacroSiteKindsBySpecifier, } from './builtin_macro_support.js';
+import { createSyntaxOnlyMacroContext } from './macro_context.js';
+import { fragmentsForMacroDefinition, parseMacroSyntaxNodeForDefinition, } from './macro_definition_support.js';
+import { collectImportedMacroDefinitionsForFile } from './macro_loader.js';
+import { collectImportedMacroSiteKindsBySpecifier as collectImportedMacroSiteKindsForSource, mergeImportedMacroSiteKinds, } from './macro_site_kind_support.js';
+import { rewriteMacroSource } from './macro_rewrite.js';
+const CANONICAL_INDENT = '    ';
+const CANONICAL_NEWLINE = '\n';
+const tsFormatting = ts;
+function applyTextChanges(text, changes) {
+    let output = text;
+    const sortedChanges = [...changes].sort((left, right) => right.span.start - left.span.start);
+    for (const change of sortedChanges) {
+        output = output.slice(0, change.span.start) + change.newText +
+            output.slice(change.span.start + change.span.length);
+    }
+    return output;
+}
+function formatCanonicalTypescriptDocument(text) {
+    const sourceFile = ts.createSourceFile('soundscript-format.ts', text, ts.ScriptTarget.Latest, true);
+    const options = {
+        ...ts.getDefaultFormatCodeSettings(),
+        baseIndentSize: 0,
+        convertTabsToSpaces: true,
+        indentSize: 4,
+        newLineCharacter: CANONICAL_NEWLINE,
+        tabSize: 4,
+    };
+    const formatContext = tsFormatting.formatting.getFormatContext(options, {
+        getNewLine: () => options.newLineCharacter,
+    });
+    const changes = tsFormatting.formatting.formatDocument(sourceFile, formatContext);
+    return applyTextChanges(text, changes);
+}
+function formatCanonicalExpression(text) {
+    const wrappedText = `const __sts_temp = ${text};\n`;
+    const sourceFile = ts.createSourceFile('soundscript-expression.ts', wrappedText, ts.ScriptTarget.Latest, true);
+    const statement = sourceFile.statements[0];
+    if (!statement || !ts.isVariableStatement(statement)) {
+        return text;
+    }
+    const initializer = statement.declarationList.declarations[0]?.initializer;
+    if (!initializer) {
+        return text;
+    }
+    return ts.createPrinter({ newLine: ts.NewLineKind.LineFeed }).printNode(ts.EmitHint.Expression, initializer, sourceFile);
+}
+function formatCanonicalBlock(text) {
+    const wrappedText = `function __sts_temp() ${text}\n`;
+    const sourceFile = ts.createSourceFile('soundscript-block.ts', wrappedText, ts.ScriptTarget.Latest, true);
+    const statement = sourceFile.statements[0];
+    if (!statement || !ts.isFunctionDeclaration(statement) || !statement.body) {
+        return text;
+    }
+    return ts.createPrinter({ newLine: ts.NewLineKind.LineFeed }).printNode(ts.EmitHint.Unspecified, statement.body, sourceFile);
+}
+function indentReplacementText(text, lineIndent) {
+    const lines = text.split(CANONICAL_NEWLINE);
+    return lines.map((line, index) => {
+        if (index === 0 || line.length === 0) {
+            return line;
+        }
+        return `${lineIndent}${line}`;
+    }).join(CANONICAL_NEWLINE);
+}
+function replacePlaceholder(text, placeholder, replacement) {
+    let output = '';
+    let cursor = 0;
+    while (cursor < text.length) {
+        const matchIndex = text.indexOf(placeholder, cursor);
+        if (matchIndex === -1) {
+            output += text.slice(cursor);
+            break;
+        }
+        output += text.slice(cursor, matchIndex);
+        const lineStart = text.lastIndexOf(CANONICAL_NEWLINE, matchIndex - 1) + 1;
+        const linePrefix = text.slice(lineStart, matchIndex);
+        const lineIndent = (/^[\t ]*/u.exec(linePrefix)?.[0]) ?? '';
+        output += indentReplacementText(replacement, lineIndent);
+        cursor = matchIndex + placeholder.length;
+    }
+    return output;
+}
+function formatCanonicalArgument(macroDefinitions, fileName, sourceText, argument) {
+    const argumentText = sourceText.slice(argument.span.start, argument.span.end);
+    return argument.kind === 'ExprArg'
+        ? formatMacroAwareRegionCanonical(fileName, argumentText, 'expression', macroDefinitions)
+        : formatMacroAwareRegionCanonical(fileName, argumentText, 'block', macroDefinitions);
+}
+function formatCanonicalDeclaration(invocation, sourceText, macroDefinitions) {
+    if (!invocation.declarationSpan) {
+        return sourceText.slice(invocation.span.start, invocation.span.end);
+    }
+    return formatMacroAwareRegionCanonical(invocation.fileName, sourceText.slice(invocation.declarationSpan.start, invocation.declarationSpan.end), 'file', macroDefinitions).trimEnd();
+}
+function formatCanonicalCallMacroInvocation(invocation, sourceText, macroDefinitions) {
+    const callPrefix = invocation.nameText;
+    switch (invocation.invocationKind) {
+        case 'block': {
+            const [argument] = invocation.argumentSpans;
+            const blockArgument = argument?.kind === 'BlockArg' ? argument : undefined;
+            const blockText = blockArgument
+                ? sourceText.slice(blockArgument.span.start, blockArgument.span.end)
+                : sourceText.slice(invocation.span.start, invocation.span.end);
+            return `${callPrefix}(() => ${formatMacroAwareRegionCanonical(invocation.fileName, blockText, 'block', macroDefinitions)})`;
+        }
+        case 'arglist': {
+            const formattedArguments = invocation.argumentSpans.map((argument) => formatCanonicalArgument(macroDefinitions, invocation.fileName, sourceText, argument));
+            return `${callPrefix}(${formattedArguments.join(', ')})`;
+        }
+        case 'arglist+block': {
+            const formattedArguments = invocation.argumentSpans.map((argument) => formatCanonicalArgument(macroDefinitions, invocation.fileName, sourceText, argument));
+            const formattedBlock = invocation.trailingBlockSpan
+                ? formatMacroAwareRegionCanonical(invocation.fileName, sourceText.slice(invocation.trailingBlockSpan.start, invocation.trailingBlockSpan.end), 'block', macroDefinitions)
+                : '{}';
+            return `${callPrefix}(${[...formattedArguments, `() => ${formattedBlock}`].join(', ')})`;
+        }
+        case 'decl':
+        case 'arglist+decl':
+            return sourceText.slice(invocation.span.start, invocation.span.end);
+    }
+}
+function formatCanonicalMacroInvocationFallback(invocation, sourceText, macroDefinitions) {
+    if (invocation.siteKind === 'tag') {
+        const [templateArgument] = invocation.argumentSpans;
+        const templateText = templateArgument
+            ? formatCanonicalArgument(macroDefinitions, invocation.fileName, sourceText, templateArgument)
+            : sourceText.slice(invocation.span.start, invocation.span.end);
+        return `${invocation.nameText}${templateText}`;
+    }
+    if (invocation.siteKind === 'annotation') {
+        return `// #[${invocation.nameText}]\n${formatCanonicalDeclaration(invocation, sourceText, macroDefinitions)}`;
+    }
+    return formatCanonicalCallMacroInvocation(invocation, sourceText, macroDefinitions);
+}
+function formatCanonicalRewrittenText(text, regionKind) {
+    switch (regionKind) {
+        case 'expression':
+            return formatCanonicalExpression(text);
+        case 'block':
+            return formatCanonicalBlock(text);
+        case 'file':
+            return formatCanonicalTypescriptDocument(text);
+    }
+}
+function collectImportedMacroDefinitions(fileName, text, bySpecifier) {
+    const sourceFile = ts.createSourceFile(fileName, text, ts.ScriptTarget.Latest, true);
+    return collectImportedMacroDefinitionsForFile(sourceFile, bySpecifier, getAlwaysAvailableBuiltinMacroDefinitions());
+}
+function collectPotentialFormattingMacroSiteKinds(fileName, text) {
+    return collectImportedMacroSiteKindsForSource(fileName, text, {
+        explicitSiteKindsBySpecifier: getBuiltinMacroSiteKindsBySpecifier(),
+        useSyntaxFallback: true,
+    });
+}
+export function requiresProjectMacroDefinitionsForFormatting(fileName, text) {
+    const importedMacroSiteKindsBySpecifier = collectPotentialFormattingMacroSiteKinds(fileName, text);
+    const rewriteResult = rewriteMacroSource(fileName, text, importedMacroSiteKindsBySpecifier, getAlwaysAvailableBuiltinMacroSiteKinds());
+    if (rewriteResult.diagnostics.length > 0 || rewriteResult.replacements.length === 0) {
+        return false;
+    }
+    const builtinDefinitions = collectImportedMacroDefinitions(fileName, text, getBuiltinMacroDefinitionsBySpecifier());
+    for (const invocation of rewriteResult.macrosById.values()) {
+        if (!builtinDefinitions.has(invocation.nameText)) {
+            return true;
+        }
+    }
+    return false;
+}
+function formatMacroInvocationWithHook(invocation, sourceText, macroDefinitions) {
+    const definition = macroDefinitions.get(invocation.nameText);
+    if (!definition) {
+        return null;
+    }
+    try {
+        const syntaxOnlyContext = createSyntaxOnlyMacroContext(invocation, sourceText);
+        const formatContext = {
+            formatBlock(text) {
+                return formatMacroAwareRegionCanonical(invocation.fileName, text, 'block', macroDefinitions);
+            },
+            formatExpression(text) {
+                return formatMacroAwareRegionCanonical(invocation.fileName, text, 'expression', macroDefinitions);
+            },
+        };
+        const node = parseMacroSyntaxNodeForDefinition(definition, syntaxOnlyContext);
+        if (definition.format && node) {
+            return definition.format({
+                ...formatContext,
+                node,
+            });
+        }
+        const fragments = fragmentsForMacroDefinition(definition, syntaxOnlyContext);
+        if (fragments.some((fragment) => fragment.format)) {
+            return formatMacroInvocationWithFormattedFragments(invocation, sourceText, fragments, formatContext);
+        }
+    }
+    catch {
+        return null;
+    }
+    return null;
+}
+function formatMacroInvocationWithFormattedBlock(invocation, sourceText, macroDefinitions, formattedBlock) {
+    if (invocation.siteKind !== 'call') {
+        return formatCanonicalMacroInvocationFallback(invocation, sourceText, macroDefinitions);
+    }
+    switch (invocation.invocationKind) {
+        case 'block':
+            return `${invocation.nameText}(() => ${formattedBlock})`;
+        case 'arglist': {
+            const formattedArguments = invocation.argumentSpans.map((argument) => formatCanonicalArgument(macroDefinitions, invocation.fileName, sourceText, argument));
+            return `${invocation.nameText}(${formattedArguments.join(', ')})`;
+        }
+        case 'arglist+block': {
+            const formattedArguments = invocation.argumentSpans.map((argument) => formatCanonicalArgument(macroDefinitions, invocation.fileName, sourceText, argument));
+            return `${invocation.nameText}(${[...formattedArguments, `() => ${formattedBlock}`].join(', ')})`;
+        }
+        case 'decl':
+            return formatCanonicalMacroInvocationFallback(invocation, sourceText, macroDefinitions);
+        case 'arglist+decl': {
+            return formatCanonicalMacroInvocationFallback(invocation, sourceText, macroDefinitions);
+        }
+    }
+}
+function formatMacroInvocationWithFormattedFragments(invocation, sourceText, fragments, formatContext) {
+    let formattedText = sourceText.slice(invocation.span.start, invocation.span.end);
+    const sortedFragments = [...fragments]
+        .filter((fragment) => typeof fragment.format === 'function')
+        .sort((left, right) => right.span.start - left.span.start);
+    for (const fragment of sortedFragments) {
+        const replacement = fragment.format?.(formatContext);
+        if (!replacement) {
+            continue;
+        }
+        const relativeStart = fragment.span.start - invocation.span.start;
+        const relativeEnd = fragment.span.end - invocation.span.start;
+        formattedText = formattedText.slice(0, relativeStart) + replacement +
+            formattedText.slice(relativeEnd);
+    }
+    return formattedText;
+}
+function formatMacroAwareRegionCanonical(fileName, text, regionKind, macroDefinitions, importedMacroSiteKindsBySpecifier = getBuiltinMacroSiteKindsBySpecifier()) {
+    const rewriteResult = rewriteMacroSource(fileName, text, importedMacroSiteKindsBySpecifier, getAlwaysAvailableBuiltinMacroSiteKinds());
+    if (rewriteResult.diagnostics.length > 0) {
+        return text;
+    }
+    let formattedText = formatCanonicalRewrittenText(rewriteResult.rewrittenText, regionKind);
+    const replacements = [...rewriteResult.replacements].sort((left, right) => left.id - right.id);
+    for (const replacement of replacements) {
+        const invocation = rewriteResult.macrosById.get(replacement.id);
+        if (!invocation) {
+            continue;
+        }
+        const hookFormattedText = formatMacroInvocationWithHook(invocation, text, macroDefinitions);
+        formattedText = replacePlaceholder(formattedText, replacement.rewriteText, hookFormattedText ??
+            formatCanonicalMacroInvocationFallback(invocation, text, macroDefinitions));
+    }
+    return formattedText;
+}
+function applyIndentStyle(text, indentText) {
+    return text.split(CANONICAL_NEWLINE).map((line) => {
+        const leadingWhitespace = (/^( +)/u.exec(line)?.[0]) ?? '';
+        if (leadingWhitespace.length === 0) {
+            return line;
+        }
+        const indentLevels = Math.floor(leadingWhitespace.length / CANONICAL_INDENT.length);
+        const remainder = leadingWhitespace.length % CANONICAL_INDENT.length;
+        return indentText.repeat(indentLevels) + ' '.repeat(remainder) +
+            line.slice(leadingWhitespace.length);
+    }).join(CANONICAL_NEWLINE);
+}
+function applyOutputStyle(text, options) {
+    const indentText = options.indentText ?? CANONICAL_INDENT;
+    const newLine = options.newLine ?? CANONICAL_NEWLINE;
+    const withIndentation = indentText === CANONICAL_INDENT
+        ? text
+        : applyIndentStyle(text, indentText);
+    return newLine === CANONICAL_NEWLINE
+        ? withIndentation
+        : withIndentation.replaceAll(CANONICAL_NEWLINE, newLine);
+}
+export function formatSoundscriptText(fileName, text, options = {}) {
+    const importedMacroSiteKindsBySpecifier = mergeImportedMacroSiteKinds(collectPotentialFormattingMacroSiteKinds(fileName, text), options.importedMacroSiteKindsBySpecifier ?? new Map());
+    const macroDefinitions = options.macroDefinitions ??
+        collectImportedMacroDefinitions(fileName, text, options.macroDefinitionsBySpecifier ?? getBuiltinMacroDefinitionsBySpecifier());
+    return applyOutputStyle(formatMacroAwareRegionCanonical(fileName, text, 'file', macroDefinitions, importedMacroSiteKindsBySpecifier), options);
+}
+export function formatSoundscriptMacroInvocation(fileName, text, replacement) {
+    const rewriteResult = rewriteMacroSource(fileName, text, new Map(), getAlwaysAvailableBuiltinMacroSiteKinds());
+    const invocation = rewriteResult.macrosById.get(replacement.id);
+    if (!invocation) {
+        return text.slice(replacement.originalSpan.start, replacement.originalSpan.end);
+    }
+    const macroDefinitions = collectImportedMacroDefinitions(fileName, text, getBuiltinMacroDefinitionsBySpecifier());
+    return formatMacroInvocationWithHook(invocation, text, macroDefinitions) ??
+        formatCanonicalMacroInvocationFallback(invocation, text, macroDefinitions);
+}