@soundscript/soundscript 0.1.13 → 0.1.15

package/project-transform/src/editor_diagnostics_worker.js

@@ -0,0 +1,176 @@
+import { dirname } from './platform/path.js';
+import { runtimeStdinReadable, runtimeStdoutWritable } from './platform/host.js';
+import { analyzePreparedProject, disposePreparedAnalysisProject, filterAnalyzedDiagnosticsForFile, prepareProjectAnalysis, } from './checker/analyze_project.js';
+import { isSoundscriptSourceFile } from './frontend/project_frontend.js';
+function createWorkerContext() {
+    return {
+        documents: new Map(),
+        projects: new Map(),
+    };
+}
+function serializeDiagnostic(diagnostic) {
+    const startLine = Math.max((diagnostic.line ?? 1) - 1, 0);
+    const startCharacter = Math.max((diagnostic.column ?? 1) - 1, 0);
+    const endLine = Math.max((diagnostic.endLine ?? diagnostic.line ?? 1) - 1, startLine);
+    const endCharacter = diagnostic.endColumn !== undefined
+        ? Math.max(diagnostic.endColumn - 1, 0)
+        : endLine === startLine
+            ? startCharacter + 1
+            : 0;
+    return {
+        code: diagnostic.code,
+        message: diagnostic.message,
+        range: {
+            start: {
+                line: startLine,
+                character: startCharacter,
+            },
+            end: {
+                line: endLine,
+                character: endLine === startLine
+                    ? Math.max(endCharacter, startCharacter + 1)
+                    : endCharacter,
+            },
+        },
+        severity: diagnostic.category === 'warning' ? 2 : diagnostic.category === 'message' ? 3 : 1,
+        source: diagnostic.source,
+    };
+}
+async function writeResponse(writer, payload) {
+    await writer.write(new TextEncoder().encode(`${JSON.stringify(payload)}\n`));
+}
+function fileOverridesForProject(context, projectPath) {
+    const projectDirectory = dirname(projectPath);
+    const overrides = new Map();
+    for (const [filePath, document] of context.documents.entries()) {
+        if (!filePath.startsWith(projectDirectory)) {
+            continue;
+        }
+        overrides.set(filePath, document.text);
+    }
+    return overrides;
+}
+function additionalRootNamesForProject(context, projectPath) {
+    const projectDirectory = dirname(projectPath);
+    return [...context.documents.keys()]
+        .filter((filePath) => filePath.startsWith(projectDirectory) && isSoundscriptSourceFile(filePath))
+        .sort();
+}
+async function handleRequest(context, request) {
+    switch (request.method) {
+        case 'initialize':
+            return { ok: true };
+        case 'syncDocument': {
+            const filePath = typeof request.params?.filePath === 'string'
+                ? request.params.filePath
+                : undefined;
+            const text = typeof request.params?.text === 'string' ? request.params.text : undefined;
+            const version = typeof request.params?.version === 'number'
+                ? request.params.version
+                : undefined;
+            if (!filePath || text === undefined || version === undefined) {
+                throw new Error('syncDocument requires filePath, text, and version.');
+            }
+            context.documents.set(filePath, { text, version });
+            return { ok: true };
+        }
+        case 'closeDocument': {
+            const filePath = typeof request.params?.filePath === 'string'
+                ? request.params.filePath
+                : undefined;
+            if (!filePath) {
+                throw new Error('closeDocument requires filePath.');
+            }
+            context.documents.delete(filePath);
+            return { ok: true };
+        }
+        case 'diagnostics': {
+            const filePath = typeof request.params?.filePath === 'string'
+                ? request.params.filePath
+                : undefined;
+            const projectPath = typeof request.params?.projectPath === 'string'
+                ? request.params.projectPath
+                : undefined;
+            if (!filePath || !projectPath) {
+                throw new Error('diagnostics requires filePath and projectPath.');
+            }
+            const fileOverrides = fileOverridesForProject(context, projectPath);
+            const additionalRootNames = additionalRootNamesForProject(context, projectPath);
+            const cachedProject = context.projects.get(projectPath);
+            const preparedProject = prepareProjectAnalysis({
+                additionalRootNames,
+                fileOverrides,
+                projectPath,
+                workingDirectory: dirname(projectPath),
+            }, cachedProject?.preparedProject);
+            disposePreparedAnalysisProject(cachedProject?.preparedProject, preparedProject);
+            const analyzedProject = cachedProject?.preparedProject === preparedProject &&
+                cachedProject.analyzedProject
+                ? cachedProject.analyzedProject
+                : analyzePreparedProject(preparedProject);
+            context.projects.set(projectPath, { preparedProject, analyzedProject });
+            return {
+                diagnostics: filterAnalyzedDiagnosticsForFile(analyzedProject.diagnostics, filePath)
+                    .map((diagnostic) => serializeDiagnostic(diagnostic)),
+            };
+        }
+        default:
+            throw new Error(`Unknown editor worker method: ${request.method ?? '<missing>'}`);
+    }
+}
+export async function runEditorDiagnosticsWorker(options = {}) {
+    const readable = options.readable ?? runtimeStdinReadable();
+    const writable = options.writable ?? runtimeStdoutWritable();
+    const reader = readable.getReader();
+    const writer = writable.getWriter();
+    const context = createWorkerContext();
+    const decoder = new TextDecoder();
+    let buffer = '';
+    try {
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done) {
+                break;
+            }
+            buffer += decoder.decode(value, { stream: true });
+            while (true) {
+                const newlineIndex = buffer.indexOf('\n');
+                if (newlineIndex === -1) {
+                    break;
+                }
+                const line = buffer.slice(0, newlineIndex).trim();
+                buffer = buffer.slice(newlineIndex + 1);
+                if (line.length === 0) {
+                    continue;
+                }
+                let request;
+                try {
+                    request = JSON.parse(line);
+                }
+                catch (error) {
+                    await writeResponse(writer, {
+                        error: error instanceof Error ? error.message : String(error),
+                    });
+                    continue;
+                }
+                try {
+                    const result = await handleRequest(context, request);
+                    await writeResponse(writer, {
+                        id: request.id,
+                        result,
+                    });
+                }
+                catch (error) {
+                    await writeResponse(writer, {
+                        id: request.id,
+                        error: error instanceof Error ? error.message : String(error),
+                    });
+                }
+            }
+        }
+    }
+    finally {
+        reader.releaseLock();
+        writer.releaseLock();
+    }
+}

package/project-transform/src/editor_diagnostics_worker.ts

@@ -0,0 +1,250 @@
+import { dirname } from './platform/path.ts';
+import { runtimeStdinReadable, runtimeStdoutWritable } from './platform/host.ts';
+
+import {
+  analyzePreparedProject,
+  disposePreparedAnalysisProject,
+  filterAnalyzedDiagnosticsForFile,
+  type PreparedAnalysisProject,
+  prepareProjectAnalysis,
+} from './checker/analyze_project.ts';
+import type { MergedDiagnostic } from './checker/diagnostics.ts';
+import type { AnalyzeProjectResult } from './service/types.ts';
+import { isSoundscriptSourceFile } from './frontend/project_frontend.ts';
+
+interface JsonRpcLikeRequest {
+  id?: number;
+  method?: string;
+  params?: Record<string, unknown>;
+}
+
+interface SyncedDocument {
+  text: string;
+  version: number;
+}
+
+interface WorkerProjectState {
+  analyzedProject?: AnalyzeProjectResult;
+  preparedProject?: PreparedAnalysisProject;
+}
+
+interface WorkerContext {
+  documents: Map<string, SyncedDocument>;
+  projects: Map<string, WorkerProjectState>;
+}
+
+interface DiagnosticsWorkerOptions {
+  readable?: ReadableStream<Uint8Array>;
+  writable?: WritableStream<Uint8Array>;
+}
+
+interface SerializedWorkerDiagnostic {
+  code: string;
+  message: string;
+  range: {
+    end: { character: number; line: number };
+    start: { character: number; line: number };
+  };
+  severity: number;
+  source: string;
+}
+
+function createWorkerContext(): WorkerContext {
+  return {
+    documents: new Map(),
+    projects: new Map(),
+  };
+}
+
+function serializeDiagnostic(diagnostic: MergedDiagnostic): SerializedWorkerDiagnostic {
+  const startLine = Math.max((diagnostic.line ?? 1) - 1, 0);
+  const startCharacter = Math.max((diagnostic.column ?? 1) - 1, 0);
+  const endLine = Math.max((diagnostic.endLine ?? diagnostic.line ?? 1) - 1, startLine);
+  const endCharacter = diagnostic.endColumn !== undefined
+    ? Math.max(diagnostic.endColumn - 1, 0)
+    : endLine === startLine
+    ? startCharacter + 1
+    : 0;
+  return {
+    code: diagnostic.code,
+    message: diagnostic.message,
+    range: {
+      start: {
+        line: startLine,
+        character: startCharacter,
+      },
+      end: {
+        line: endLine,
+        character: endLine === startLine
+          ? Math.max(endCharacter, startCharacter + 1)
+          : endCharacter,
+      },
+    },
+    severity: diagnostic.category === 'warning' ? 2 : diagnostic.category === 'message' ? 3 : 1,
+    source: diagnostic.source,
+  };
+}
+
+async function writeResponse(
+  writer: WritableStreamDefaultWriter<Uint8Array>,
+  payload: unknown,
+): Promise<void> {
+  await writer.write(new TextEncoder().encode(`${JSON.stringify(payload)}\n`));
+}
+
+function fileOverridesForProject(
+  context: WorkerContext,
+  projectPath: string,
+): ReadonlyMap<string, string> {
+  const projectDirectory = dirname(projectPath);
+  const overrides = new Map<string, string>();
+  for (const [filePath, document] of context.documents.entries()) {
+    if (!filePath.startsWith(projectDirectory)) {
+      continue;
+    }
+    overrides.set(filePath, document.text);
+  }
+  return overrides;
+}
+
+function additionalRootNamesForProject(
+  context: WorkerContext,
+  projectPath: string,
+): readonly string[] {
+  const projectDirectory = dirname(projectPath);
+  return [...context.documents.keys()]
+    .filter((filePath) =>
+      filePath.startsWith(projectDirectory) && isSoundscriptSourceFile(filePath)
+    )
+    .sort();
+}
+
+async function handleRequest(
+  context: WorkerContext,
+  request: JsonRpcLikeRequest,
+): Promise<unknown> {
+  switch (request.method) {
+    case 'initialize':
+      return { ok: true };
+    case 'syncDocument': {
+      const filePath = typeof request.params?.filePath === 'string'
+        ? request.params.filePath
+        : undefined;
+      const text = typeof request.params?.text === 'string' ? request.params.text : undefined;
+      const version = typeof request.params?.version === 'number'
+        ? request.params.version
+        : undefined;
+      if (!filePath || text === undefined || version === undefined) {
+        throw new Error('syncDocument requires filePath, text, and version.');
+      }
+      context.documents.set(filePath, { text, version });
+      return { ok: true };
+    }
+    case 'closeDocument': {
+      const filePath = typeof request.params?.filePath === 'string'
+        ? request.params.filePath
+        : undefined;
+      if (!filePath) {
+        throw new Error('closeDocument requires filePath.');
+      }
+      context.documents.delete(filePath);
+      return { ok: true };
+    }
+    case 'diagnostics': {
+      const filePath = typeof request.params?.filePath === 'string'
+        ? request.params.filePath
+        : undefined;
+      const projectPath = typeof request.params?.projectPath === 'string'
+        ? request.params.projectPath
+        : undefined;
+      if (!filePath || !projectPath) {
+        throw new Error('diagnostics requires filePath and projectPath.');
+      }
+
+      const fileOverrides = fileOverridesForProject(context, projectPath);
+      const additionalRootNames = additionalRootNamesForProject(context, projectPath);
+      const cachedProject = context.projects.get(projectPath);
+      const preparedProject = prepareProjectAnalysis(
+        {
+          additionalRootNames,
+          fileOverrides,
+          projectPath,
+          workingDirectory: dirname(projectPath),
+        },
+        cachedProject?.preparedProject,
+      );
+      disposePreparedAnalysisProject(cachedProject?.preparedProject, preparedProject);
+      const analyzedProject = cachedProject?.preparedProject === preparedProject &&
+          cachedProject.analyzedProject
+        ? cachedProject.analyzedProject
+        : analyzePreparedProject(preparedProject);
+      context.projects.set(projectPath, { preparedProject, analyzedProject });
+      return {
+        diagnostics: filterAnalyzedDiagnosticsForFile(analyzedProject.diagnostics, filePath)
+          .map((diagnostic) => serializeDiagnostic(diagnostic)),
+      };
+    }
+    default:
+      throw new Error(`Unknown editor worker method: ${request.method ?? '<missing>'}`);
+  }
+}
+
+export async function runEditorDiagnosticsWorker(
+  options: DiagnosticsWorkerOptions = {},
+): Promise<void> {
+  const readable = options.readable ?? runtimeStdinReadable();
+  const writable = options.writable ?? runtimeStdoutWritable();
+  const reader = readable.getReader();
+  const writer = writable.getWriter();
+  const context = createWorkerContext();
+  const decoder = new TextDecoder();
+  let buffer = '';
+
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) {
+        break;
+      }
+      buffer += decoder.decode(value, { stream: true });
+      while (true) {
+        const newlineIndex = buffer.indexOf('\n');
+        if (newlineIndex === -1) {
+          break;
+        }
+
+        const line = buffer.slice(0, newlineIndex).trim();
+        buffer = buffer.slice(newlineIndex + 1);
+        if (line.length === 0) {
+          continue;
+        }
+
+        let request: JsonRpcLikeRequest;
+        try {
+          request = JSON.parse(line) as JsonRpcLikeRequest;
+        } catch (error) {
+          await writeResponse(writer, {
+            error: error instanceof Error ? error.message : String(error),
+          });
+          continue;
+        }
+
+        try {
+          const result = await handleRequest(context, request);
+          await writeResponse(writer, {
+            id: request.id,
+            result,
+          });
+        } catch (error) {
+          await writeResponse(writer, {
+            id: request.id,
+            error: error instanceof Error ? error.message : String(error),
+          });
+        }
+      }
+    }
+  } finally {
+    reader.releaseLock();
+    writer.releaseLock();
+  }
+}

package/project-transform/src/editor_projection.js

@@ -0,0 +1,224 @@
+import { dirname } from './platform/path.js';
+import ts from 'typescript';
+import { createSoundStdlibCompilerHost } from './bundled/sound_stdlib.js';
+import { getConfigFileParsingDiagnostics, loadConfig, resolveExpansionEnabled } from './config.js';
+import { createBuiltinExpandedProgram } from './frontend/builtin_macro_support.js';
+import { mapProgramEnclosingRangeToSource, mapProgramPositionToSource, mapProgramRangeToSource, } from './frontend/project_frontend.js';
+import { getStdlibDeclarationEntriesBySpecifier } from './frontend/std_package_support.js';
+const STDLIB_DECLARATION_ENTRIES_BY_SPECIFIER = getStdlibDeclarationEntriesBySpecifier();
+function projectPreparedStage(stage) {
+    return {
+        lineMappings: stage.lineMappings?.map(projectLineMapping),
+        replacements: stage.replacements.map((replacement) => ({
+            mappedSegments: replacement.mappedSegments?.map((segment) => ({
+                originalEnd: segment.originalEnd,
+                originalStart: segment.originalStart,
+                rewrittenEnd: segment.rewrittenEnd,
+                rewrittenStart: segment.rewrittenStart,
+            })),
+            originalSpan: {
+                start: replacement.originalSpan.start,
+                end: replacement.originalSpan.end,
+            },
+            rewrittenSpan: {
+                start: replacement.rewrittenSpan.start,
+                end: replacement.rewrittenSpan.end,
+            },
+        })),
+        rewrittenText: stage.rewrittenText,
+    };
+}
+function projectLineMapping(mapping) {
+    return {
+        originalEnd: mapping.originalEnd,
+        originalStart: mapping.originalStart,
+        rewrittenEnd: mapping.rewrittenEnd,
+        rewrittenStart: mapping.rewrittenStart,
+    };
+}
+export function collectVirtualStdlibModules(projectedText, declarationEntriesBySpecifier = STDLIB_DECLARATION_ENTRIES_BY_SPECIFIER) {
+    const modules = [];
+    for (const [specifier, declarationEntry] of declarationEntriesBySpecifier.entries()) {
+        if (!projectedText.includes(specifier)) {
+            continue;
+        }
+        modules.push({
+            fileName: declarationEntry.fileName,
+            specifier,
+            text: declarationEntry.text,
+        });
+    }
+    return modules;
+}
+function getPreparedSourceForSourceFile(expandedProgram, sourceFileName) {
+    return expandedProgram.diagnosticPreparedFiles.get(sourceFileName) ??
+        expandedProgram.analysisPreparedProgram.preparedHost.getPreparedSourceFile(sourceFileName);
+}
+function collectProjectedDependencyModules(expandedProgram, rootSourceFileName) {
+    const modules = [];
+    const seenProjectedFileNames = new Set();
+    for (const sourceFile of expandedProgram.analysisPreparedProgram.program.getSourceFiles()) {
+        const sourceFileName = expandedProgram.analysisPreparedProgram.toSourceFileName(sourceFile.fileName);
+        if (sourceFileName === rootSourceFileName ||
+            !sourceFileName.endsWith('.sts')) {
+            continue;
+        }
+        const projectedFileName = expandedProgram.analysisPreparedProgram.toProgramFileName(sourceFileName);
+        if (seenProjectedFileNames.has(projectedFileName)) {
+            continue;
+        }
+        const preparedSource = getPreparedSourceForSourceFile(expandedProgram, sourceFileName);
+        if (!preparedSource) {
+            continue;
+        }
+        seenProjectedFileNames.add(projectedFileName);
+        modules.push({
+            fileName: projectedFileName,
+            originalText: preparedSource.originalText,
+            postRewriteStage: preparedSource.postRewriteStage
+                ? projectPreparedStage(preparedSource.postRewriteStage)
+                : undefined,
+            rewriteStage: projectPreparedStage(preparedSource.rewriteResult),
+            specifier: sourceFileName,
+            sourceFileName,
+            text: applySemanticMacroPlaceholderDeclarations(expandedProgram, sourceFileName, preparedSource.rewrittenText),
+        });
+    }
+    return modules;
+}
+function findDeepestNodeContainingPosition(root, position) {
+    if (position < root.getFullStart() || position >= root.getEnd()) {
+        return null;
+    }
+    let current = root;
+    root.forEachChild((child) => {
+        const nested = findDeepestNodeContainingPosition(child, position);
+        if (nested) {
+            current = nested;
+        }
+    });
+    return current;
+}
+function findCallExpressionForInvocation(sourceFile, invocationStart) {
+    let current = findDeepestNodeContainingPosition(sourceFile, invocationStart);
+    while (current && !ts.isSourceFile(current)) {
+        if (ts.isCallExpression(current)) {
+            return current;
+        }
+        current = current.parent;
+    }
+    return null;
+}
+function collectSemanticMacroPlaceholderDeclarations(expandedProgram, sourceFileName) {
+    const sourceFile = expandedProgram.preparedProgram.program.getSourceFile(expandedProgram.preparedProgram.toProgramFileName(sourceFileName));
+    if (!sourceFile) {
+        return [];
+    }
+    const checker = expandedProgram.preparedProgram.program.getTypeChecker();
+    const declarations = [];
+    for (const placeholder of expandedProgram.preparedProgram.placeholderIndex().entries()) {
+        if (placeholder.fileName !== sourceFileName || placeholder.invocation.rewriteKind !== 'expr') {
+            continue;
+        }
+        const callExpression = findCallExpressionForInvocation(sourceFile, placeholder.invocation.nameSpan.start);
+        if (!callExpression) {
+            continue;
+        }
+        const typeNode = placeholder.invocation.nameText === 'Try'
+            ? callExpression.arguments[0]
+            : callExpression;
+        if (!typeNode) {
+            continue;
+        }
+        const type = checker.getTypeAtLocation(typeNode);
+        const typeText = checker.typeToString(type, typeNode, ts.TypeFormatFlags.NoTruncation | ts.TypeFormatFlags.UseAliasDefinedOutsideCurrentScope);
+        if (!typeText || typeText === 'never') {
+            continue;
+        }
+        declarations.push(`declare function __sts_macro_expr(id: ${placeholder.id}): ${typeText};`);
+    }
+    return declarations;
+}
+function applySemanticMacroPlaceholderDeclarations(expandedProgram, sourceFileName, projectedText) {
+    const declarations = collectSemanticMacroPlaceholderDeclarations(expandedProgram, sourceFileName);
+    if (declarations.length === 0) {
+        return projectedText;
+    }
+    const marker = 'declare function __sts_macro_expr(id: number): never;';
+    const markerIndex = projectedText.indexOf(marker);
+    if (markerIndex === -1) {
+        return projectedText;
+    }
+    return projectedText.slice(0, markerIndex) +
+        `${declarations.join('\n')}\n` +
+        projectedText.slice(markerIndex);
+}
+function getProjectedPreparedSource(projectPath, filePath, expansionEnabled, fileOverrides) {
+    const loadedConfig = loadConfig(projectPath, {}, [filePath]);
+    const resolvedExpansionEnabled = resolveExpansionEnabled(expansionEnabled, loadedConfig.soundscript);
+    const rootNames = [filePath];
+    const expandedProgram = createBuiltinExpandedProgram({
+        baseHost: createSoundStdlibCompilerHost(loadedConfig.commandLine.options, dirname(projectPath)),
+        configFileParsingDiagnostics: getConfigFileParsingDiagnostics(loadedConfig.diagnostics, rootNames),
+        expansionEnabled: resolvedExpansionEnabled,
+        fileOverrides,
+        options: loadedConfig.commandLine.options,
+        projectReferences: loadedConfig.commandLine.projectReferences,
+        rootNames,
+    });
+    const sourceFileName = expandedProgram.analysisPreparedProgram.toSourceFileName(filePath);
+    const projectedPreparedSource = getPreparedSourceForSourceFile(expandedProgram, sourceFileName);
+    if (!projectedPreparedSource) {
+        throw new Error(`File is not part of the projected program: ${filePath}`);
+    }
+    return {
+        expandedProgram,
+        preparedSource: projectedPreparedSource,
+    };
+}
+export function projectEditorFile(options) {
+    const fileOverrides = options.fileOverrides ?? new Map();
+    const { expandedProgram, preparedSource } = getProjectedPreparedSource(options.projectPath, options.filePath, options.expansionEnabled, fileOverrides);
+    try {
+        const projectedText = applySemanticMacroPlaceholderDeclarations(expandedProgram, options.filePath, preparedSource.rewrittenText);
+        return {
+            filePath: options.filePath,
+            originalText: preparedSource.originalText,
+            postRewriteStage: preparedSource.postRewriteStage
+                ? projectPreparedStage(preparedSource.postRewriteStage)
+                : undefined,
+            projectedText,
+            projectPath: options.projectPath,
+            rewriteStage: projectPreparedStage(preparedSource.rewriteResult),
+            virtualModules: [
+                ...collectVirtualStdlibModules(projectedText),
+                ...collectProjectedDependencyModules(expandedProgram, options.filePath),
+            ],
+        };
+    }
+    finally {
+        expandedProgram.dispose();
+    }
+}
+function toPreparedSourceForMapping(projection) {
+    return {
+        diagnostics: [],
+        originalText: projection.originalText,
+        postRewriteStage: projection.postRewriteStage,
+        rewriteResult: projection.rewriteStage,
+        rewrittenText: projection.postRewriteStage?.rewrittenText ??
+            projection.rewriteStage.rewrittenText,
+    };
+}
+export function mapProjectedPositionToSource(projection, programPosition) {
+    const preparedSource = toPreparedSourceForMapping(projection);
+    return mapProgramPositionToSource(preparedSource, programPosition);
+}
+export function mapProjectedRangeToSource(projection, programStart, programEnd) {
+    const preparedSource = toPreparedSourceForMapping(projection);
+    return mapProgramRangeToSource(preparedSource, programStart, programEnd);
+}
+export function mapProjectedEnclosingRangeToSource(projection, programStart, programEnd) {
+    const preparedSource = toPreparedSourceForMapping(projection);
+    return mapProgramEnclosingRangeToSource(preparedSource, programStart, programEnd);
+}