@soundscript/soundscript 0.1.12 → 0.1.15

package/project-transform/src/checker/diagnostics.js

@@ -0,0 +1,112 @@
+import ts from 'typescript';
+import { relative } from '../platform/path.js';
+function toDiagnosticCategory(category) {
+    switch (category) {
+        case ts.DiagnosticCategory.Error:
+            return 'error';
+        case ts.DiagnosticCategory.Warning:
+            return 'warning';
+        case ts.DiagnosticCategory.Message:
+        case ts.DiagnosticCategory.Suggestion:
+            return 'message';
+        default: {
+            const exhaustiveCheck = category;
+            return exhaustiveCheck;
+        }
+    }
+}
+function toRelatedInformation(diagnostic) {
+    const relatedInformation = {
+        message: ts.flattenDiagnosticMessageText(diagnostic.messageText, '\n'),
+    };
+    if (diagnostic.file && diagnostic.start !== undefined) {
+        const location = diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start);
+        relatedInformation.filePath = diagnostic.file.fileName;
+        relatedInformation.line = location.line + 1;
+        relatedInformation.column = location.character + 1;
+        if (diagnostic.length !== undefined) {
+            const end = diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start + diagnostic.length);
+            relatedInformation.endLine = end.line + 1;
+            relatedInformation.endColumn = end.character + 1;
+        }
+    }
+    return relatedInformation;
+}
+export function toMergedDiagnostic(diagnostic) {
+    const message = ts.flattenDiagnosticMessageText(diagnostic.messageText, '\n');
+    const mergedDiagnostic = {
+        source: 'ts',
+        code: `TS${diagnostic.code}`,
+        category: toDiagnosticCategory(diagnostic.category),
+        message,
+    };
+    if (diagnostic.file && diagnostic.start !== undefined) {
+        const location = diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start);
+        mergedDiagnostic.filePath = diagnostic.file.fileName;
+        mergedDiagnostic.line = location.line + 1;
+        mergedDiagnostic.column = location.character + 1;
+        if (diagnostic.length !== undefined) {
+            const end = diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start + diagnostic.length);
+            mergedDiagnostic.endLine = end.line + 1;
+            mergedDiagnostic.endColumn = end.character + 1;
+        }
+    }
+    if (diagnostic.relatedInformation && diagnostic.relatedInformation.length > 0) {
+        mergedDiagnostic.relatedInformation = diagnostic.relatedInformation.map(toRelatedInformation);
+    }
+    return mergedDiagnostic;
+}
+export function remapDiagnosticFilePaths(diagnostic, remapFilePath) {
+    return {
+        ...diagnostic,
+        filePath: diagnostic.filePath ? remapFilePath(diagnostic.filePath) : diagnostic.filePath,
+        relatedInformation: diagnostic.relatedInformation?.map((relatedInformation) => ({
+            ...relatedInformation,
+            filePath: relatedInformation.filePath
+                ? remapFilePath(relatedInformation.filePath)
+                : relatedInformation.filePath,
+        })),
+    };
+}
+export function getNodeDiagnosticRange(node) {
+    const sourceFile = node.getSourceFile();
+    const start = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile));
+    const end = sourceFile.getLineAndCharacterOfPosition(node.getEnd());
+    return {
+        filePath: sourceFile.fileName,
+        line: start.line + 1,
+        column: start.character + 1,
+        endLine: end.line + 1,
+        endColumn: end.character + 1,
+    };
+}
+export function formatDiagnostic(diagnostic, workingDirectory) {
+    const location = diagnostic.filePath
+        ? `${relative(workingDirectory, diagnostic.filePath)}:${diagnostic.line ?? 1}:${diagnostic.column ?? 1}`
+        : relative(workingDirectory, workingDirectory);
+    const lines = [`${location} - ${diagnostic.category} ${diagnostic.code}: ${diagnostic.message}`];
+    for (const note of diagnostic.notes ?? []) {
+        lines.push(`  note: ${note}`);
+    }
+    if (diagnostic.hint) {
+        lines.push(`  hint: ${diagnostic.hint}`);
+    }
+    for (const relatedInformation of diagnostic.relatedInformation ?? []) {
+        const relatedLocation = relatedInformation.filePath
+            ? `${relative(workingDirectory, relatedInformation.filePath)}:${relatedInformation.line ?? 1}:${relatedInformation.column ?? 1}`
+            : relative(workingDirectory, workingDirectory);
+        lines.push(`  related: ${relatedLocation}: ${relatedInformation.message}`);
+    }
+    return lines.join('\n');
+}
+export function formatDiagnostics(diagnostics, workingDirectory) {
+    if (diagnostics.length === 0) {
+        return '';
+    }
+    return diagnostics
+        .map((diagnostic) => formatDiagnostic(diagnostic, workingDirectory))
+        .join('\n');
+}
+export function hasErrorDiagnostics(diagnostics) {
+    return diagnostics.some((diagnostic) => diagnostic.category === 'error');
+}

package/project-transform/src/checker/diagnostics.ts

@@ -0,0 +1,222 @@
+import ts from 'typescript';
+
+import type { CompilerDiagnosticCode, SoundDiagnosticCode } from './engine/diagnostic_codes.ts';
+import { relative } from '../platform/path.ts';
+
+export type DiagnosticCategory = 'error' | 'warning' | 'message';
+export type DiagnosticSource = 'ts' | 'sound' | 'compiler' | 'cli';
+export type DiagnosticFixability =
+  | 'api_redesign'
+  | 'boundary_annotation'
+  | 'local_rewrite'
+  | 'unsupported_for_now';
+
+export interface DiagnosticEvidence {
+  label: string;
+  value: string;
+}
+
+export interface DiagnosticMetadata {
+  counterexample?: string;
+  evidence?: DiagnosticEvidence[];
+  example?: string;
+  featureId?: string;
+  fixability?: DiagnosticFixability;
+  invariant?: string;
+  primarySymbol?: string;
+  replacementFamily?: string;
+  rule?: string;
+  secondarySymbol?: string;
+}
+
+export interface DiagnosticRelatedInformation {
+  message: string;
+  filePath?: string;
+  line?: number;
+  column?: number;
+  endLine?: number;
+  endColumn?: number;
+}
+
+export interface MergedDiagnostic {
+  source: DiagnosticSource;
+  code: string;
+  category: DiagnosticCategory;
+  message: string;
+  metadata?: DiagnosticMetadata;
+  notes?: string[];
+  hint?: string;
+  relatedInformation?: DiagnosticRelatedInformation[];
+  filePath?: string;
+  line?: number;
+  column?: number;
+  endLine?: number;
+  endColumn?: number;
+}
+
+export interface SoundDiagnostic extends MergedDiagnostic {
+  source: 'sound';
+  code: SoundDiagnosticCode;
+}
+
+export interface CompilerDiagnostic extends MergedDiagnostic {
+  source: 'compiler';
+  code: CompilerDiagnosticCode;
+}
+
+function toDiagnosticCategory(category: ts.DiagnosticCategory): DiagnosticCategory {
+  switch (category) {
+    case ts.DiagnosticCategory.Error:
+      return 'error';
+    case ts.DiagnosticCategory.Warning:
+      return 'warning';
+    case ts.DiagnosticCategory.Message:
+    case ts.DiagnosticCategory.Suggestion:
+      return 'message';
+    default: {
+      const exhaustiveCheck: never = category;
+      return exhaustiveCheck;
+    }
+  }
+}
+
+function toRelatedInformation(
+  diagnostic: ts.DiagnosticRelatedInformation,
+): DiagnosticRelatedInformation {
+  const relatedInformation: DiagnosticRelatedInformation = {
+    message: ts.flattenDiagnosticMessageText(diagnostic.messageText, '\n'),
+  };
+
+  if (diagnostic.file && diagnostic.start !== undefined) {
+    const location = diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start);
+    relatedInformation.filePath = diagnostic.file.fileName;
+    relatedInformation.line = location.line + 1;
+    relatedInformation.column = location.character + 1;
+
+    if (diagnostic.length !== undefined) {
+      const end = diagnostic.file.getLineAndCharacterOfPosition(
+        diagnostic.start + diagnostic.length,
+      );
+      relatedInformation.endLine = end.line + 1;
+      relatedInformation.endColumn = end.character + 1;
+    }
+  }
+
+  return relatedInformation;
+}
+
+export function toMergedDiagnostic(diagnostic: ts.Diagnostic): MergedDiagnostic {
+  const message = ts.flattenDiagnosticMessageText(diagnostic.messageText, '\n');
+  const mergedDiagnostic: MergedDiagnostic = {
+    source: 'ts',
+    code: `TS${diagnostic.code}`,
+    category: toDiagnosticCategory(diagnostic.category),
+    message,
+  };
+
+  if (diagnostic.file && diagnostic.start !== undefined) {
+    const location = diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start);
+    mergedDiagnostic.filePath = diagnostic.file.fileName;
+    mergedDiagnostic.line = location.line + 1;
+    mergedDiagnostic.column = location.character + 1;
+
+    if (diagnostic.length !== undefined) {
+      const end = diagnostic.file.getLineAndCharacterOfPosition(
+        diagnostic.start + diagnostic.length,
+      );
+      mergedDiagnostic.endLine = end.line + 1;
+      mergedDiagnostic.endColumn = end.character + 1;
+    }
+  }
+
+  if (diagnostic.relatedInformation && diagnostic.relatedInformation.length > 0) {
+    mergedDiagnostic.relatedInformation = diagnostic.relatedInformation.map(toRelatedInformation);
+  }
+
+  return mergedDiagnostic;
+}
+
+export function remapDiagnosticFilePaths<T extends MergedDiagnostic>(
+  diagnostic: T,
+  remapFilePath: (filePath: string) => string,
+): T {
+  return {
+    ...diagnostic,
+    filePath: diagnostic.filePath ? remapFilePath(diagnostic.filePath) : diagnostic.filePath,
+    relatedInformation: diagnostic.relatedInformation?.map((relatedInformation) => ({
+      ...relatedInformation,
+      filePath: relatedInformation.filePath
+        ? remapFilePath(relatedInformation.filePath)
+        : relatedInformation.filePath,
+    })),
+  };
+}
+
+export function getNodeDiagnosticRange(node: ts.Node): {
+  column: number;
+  endColumn: number;
+  endLine: number;
+  filePath: string;
+  line: number;
+} {
+  const sourceFile = node.getSourceFile();
+  const start = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile));
+  const end = sourceFile.getLineAndCharacterOfPosition(node.getEnd());
+
+  return {
+    filePath: sourceFile.fileName,
+    line: start.line + 1,
+    column: start.character + 1,
+    endLine: end.line + 1,
+    endColumn: end.character + 1,
+  };
+}
+
+export function formatDiagnostic(
+  diagnostic: MergedDiagnostic,
+  workingDirectory: string,
+): string {
+  const location = diagnostic.filePath
+    ? `${relative(workingDirectory, diagnostic.filePath)}:${diagnostic.line ?? 1}:${
+      diagnostic.column ?? 1
+    }`
+    : relative(workingDirectory, workingDirectory);
+
+  const lines = [`${location} - ${diagnostic.category} ${diagnostic.code}: ${diagnostic.message}`];
+
+  for (const note of diagnostic.notes ?? []) {
+    lines.push(`  note: ${note}`);
+  }
+
+  if (diagnostic.hint) {
+    lines.push(`  hint: ${diagnostic.hint}`);
+  }
+
+  for (const relatedInformation of diagnostic.relatedInformation ?? []) {
+    const relatedLocation = relatedInformation.filePath
+      ? `${relative(workingDirectory, relatedInformation.filePath)}:${
+        relatedInformation.line ?? 1
+      }:${relatedInformation.column ?? 1}`
+      : relative(workingDirectory, workingDirectory);
+    lines.push(`  related: ${relatedLocation}: ${relatedInformation.message}`);
+  }
+
+  return lines.join('\n');
+}
+
+export function formatDiagnostics(
+  diagnostics: readonly MergedDiagnostic[],
+  workingDirectory: string,
+): string {
+  if (diagnostics.length === 0) {
+    return '';
+  }
+
+  return diagnostics
+    .map((diagnostic) => formatDiagnostic(diagnostic, workingDirectory))
+    .join('\n');
+}
+
+export function hasErrorDiagnostics(diagnostics: readonly MergedDiagnostic[]): boolean {
+  return diagnostics.some((diagnostic) => diagnostic.category === 'error');
+}

package/project-transform/src/checker/engine/context.js

@@ -0,0 +1,235 @@
+import ts from 'typescript';
+import { createAnnotationLookup } from '../../annotation_syntax.js';
+import { normalizeRuntimeContext } from '../../config.js';
+import { isForeignSourceFile } from '../../soundscript_packages.js';
+import { createAnalysisFactStore } from './facts.js';
+function isNode(subject) {
+    return 'kind' in subject;
+}
+function traverseNode(node, visitor, isGeneratedNode) {
+    if (!ts.isSourceFile(node) && isGeneratedNode(node)) {
+        return;
+    }
+    visitor(node);
+    ts.forEachChild(node, (child) => traverseNode(child, visitor, isGeneratedNode));
+}
+export function createAnalysisContext(options) {
+    const checker = options.program.getTypeChecker();
+    const factStore = createAnalysisFactStore();
+    const nodeIds = new WeakMap();
+    const symbolIds = new WeakMap();
+    const exportSummariesBySymbolId = new Map();
+    const annotationLookups = new WeakMap();
+    const generatedNodeCache = new WeakMap();
+    const sourceFiles = options.program.getSourceFiles().filter((sourceFile) => !options.program.isSourceFileDefaultLibrary(sourceFile) &&
+        (!options.program.isSourceFileFromExternalLibrary(sourceFile) ||
+            !isForeignSourceFile(sourceFile.fileName, ts.sys)) &&
+        (options.includeSourceFile?.(sourceFile) ?? true));
+    const runtime = options.runtime ?? normalizeRuntimeContext({
+        externs: [],
+        target: 'js-node',
+    });
+    let nextNodeId = 1;
+    let nextSymbolId = 1;
+    function getSubjectCacheKey(subject) {
+        if (isNode(subject)) {
+            return `node:${context.getNodeId(subject)}`;
+        }
+        return `symbol:${context.getSymbolId(subject)}`;
+    }
+    function getCanonicalExportSummarySymbol(symbol) {
+        let currentSymbol = symbol;
+        const visitedSymbols = new Set();
+        while (!visitedSymbols.has(currentSymbol)) {
+            visitedSymbols.add(currentSymbol);
+            if (currentSymbol.flags & ts.SymbolFlags.Alias) {
+                const aliasedSymbol = checker.getAliasedSymbol(currentSymbol);
+                if (aliasedSymbol && aliasedSymbol !== currentSymbol) {
+                    currentSymbol = aliasedSymbol;
+                    continue;
+                }
+            }
+            const exportedSymbol = checker.getExportSymbolOfSymbol(currentSymbol);
+            if (exportedSymbol !== currentSymbol) {
+                currentSymbol = exportedSymbol;
+                continue;
+            }
+            return currentSymbol;
+        }
+        return currentSymbol;
+    }
+    const context = {
+        checker,
+        exportSummaries: {
+            canonicalizeSymbol(symbol) {
+                return getCanonicalExportSummarySymbol(symbol);
+            },
+            get(symbol) {
+                return exportSummariesBySymbolId.get(context.getSymbolId(getCanonicalExportSummarySymbol(symbol)));
+            },
+            set(symbol, summary) {
+                exportSummariesBySymbolId.set(context.getSymbolId(getCanonicalExportSummarySymbol(symbol)), summary);
+                return summary;
+            },
+        },
+        facts: {
+            getAliasRelationship(source, target, compute) {
+                return factStore.getOrCompute('alias', `${getSubjectCacheKey(source)}->${getSubjectCacheKey(target)}`, compute);
+            },
+            getEffectSummary(node, compute) {
+                return factStore.getOrCompute('effectSummary', `node:${context.getNodeId(node)}`, compute);
+            },
+            getFlowBranchStructure(node, compute) {
+                return factStore.getOrCompute('flowBranchStructure', `node:${context.getNodeId(node)}`, compute);
+            },
+            getFlowChildRegionStructure(node, compute) {
+                return factStore.getOrCompute('flowChildRegionStructure', `node:${context.getNodeId(node)}`, compute);
+            },
+            getFlowConditionStructure(node, compute) {
+                return factStore.getOrCompute('flowConditionStructure', `node:${context.getNodeId(node)}`, compute);
+            },
+            getFlowInvalidationStructure(node, optionsKey, compute) {
+                return factStore.getOrCompute('flowInvalidationStructure', `node:${context.getNodeId(node)}|options:${optionsKey}`, compute);
+            },
+            getFlowStatementStructure(node, compute) {
+                return factStore.getOrCompute('flowStatementStructure', `node:${context.getNodeId(node)}`, compute);
+            },
+            getFlowRegionStructure(node, optionsKey, compute) {
+                return factStore.getOrCompute('flowRegionStructure', `node:${context.getNodeId(node)}|options:${optionsKey}`, compute);
+            },
+            getForeignProjection(symbol, compute) {
+                return factStore.getOrCompute('foreignProjection', `symbol:${context.getSymbolId(symbol)}`, compute);
+            },
+            getMutability(subject, compute) {
+                return factStore.getOrCompute('mutability', getSubjectCacheKey(subject), compute);
+            },
+            getNamespaceResolver(node, compute) {
+                const key = `node:${context.getNodeId(node)}`;
+                const cached = factStore.get('namespaceResolver', key);
+                if (cached) {
+                    return cached;
+                }
+                const created = compute();
+                if (created) {
+                    factStore.set('namespaceResolver', key, created);
+                }
+                return created;
+            },
+            getNamespaceShape(node, compute) {
+                const key = `node:${context.getNodeId(node)}`;
+                const cached = factStore.get('namespaceShape', key);
+                if (cached) {
+                    return cached;
+                }
+                const created = compute();
+                if (created) {
+                    factStore.set('namespaceShape', key, created);
+                }
+                return created;
+            },
+            getNamespaceResolverSymbol(symbol) {
+                return factStore.get('namespaceResolver', `symbol:${context.getSymbolId(symbol)}`);
+            },
+            getNamespaceShapeSymbol(symbol) {
+                return factStore.get('namespaceShape', `symbol:${context.getSymbolId(symbol)}`);
+            },
+            getNarrowing(node, symbol, compute) {
+                return factStore.getOrCompute('narrowing', `node:${context.getNodeId(node)}|symbol:${context.getSymbolId(symbol)}`, compute);
+            },
+            getNonOrdinaryRecovery(node, family, compute) {
+                return factStore.getOrCompute('nonOrdinaryRecovery', `node:${context.getNodeId(node)}|family:${family}`, compute);
+            },
+            getPredicateVerificationTarget(node, compute) {
+                const key = `node:${context.getNodeId(node)}`;
+                const cached = factStore.get('predicateVerificationTarget', key);
+                if (cached) {
+                    return cached;
+                }
+                const created = compute();
+                if (created) {
+                    factStore.set('predicateVerificationTarget', key, created);
+                }
+                return created;
+            },
+            getUnsafeValueOrigin(symbol) {
+                return factStore.get('unsafeValueOrigin', `symbol:${context.getSymbolId(symbol)}`);
+            },
+            setForeignProjection(symbol, fact) {
+                factStore.set('foreignProjection', `symbol:${context.getSymbolId(symbol)}`, fact);
+                return fact;
+            },
+            setNamespaceResolverSymbol(symbol, fact) {
+                factStore.set('namespaceResolver', `symbol:${context.getSymbolId(symbol)}`, fact);
+                return fact;
+            },
+            setNamespaceShapeSymbol(symbol, fact) {
+                factStore.set('namespaceShape', `symbol:${context.getSymbolId(symbol)}`, fact);
+                return fact;
+            },
+            setSymbolProvenance(symbol, fact) {
+                factStore.set('symbolProvenance', `symbol:${context.getSymbolId(symbol)}`, fact);
+                return fact;
+            },
+            setUnsafeValueOrigin(symbol, fact) {
+                factStore.set('unsafeValueOrigin', `symbol:${context.getSymbolId(symbol)}`, fact);
+                return fact;
+            },
+            getSymbolProvenance(symbol, compute) {
+                return factStore.getOrCompute('symbolProvenance', `symbol:${context.getSymbolId(symbol)}`, compute);
+            },
+        },
+        isGeneratedNode(node) {
+            const cached = generatedNodeCache.get(node);
+            if (cached !== undefined) {
+                return cached;
+            }
+            const generated = options.isGeneratedNode?.(node) ?? false;
+            generatedNodeCache.set(node, generated);
+            return generated;
+        },
+        program: options.program,
+        runtime,
+        workingDirectory: options.workingDirectory,
+        forEachSourceFile(visitor) {
+            for (const sourceFile of sourceFiles) {
+                visitor(sourceFile);
+            }
+        },
+        getAnnotationLookup(sourceFile) {
+            const cachedLookup = annotationLookups.get(sourceFile);
+            if (cachedLookup) {
+                return cachedLookup;
+            }
+            const createdLookup = createAnnotationLookup(sourceFile);
+            annotationLookups.set(sourceFile, createdLookup);
+            return createdLookup;
+        },
+        getNodeId(node) {
+            const cachedId = nodeIds.get(node);
+            if (cachedId !== undefined) {
+                return cachedId;
+            }
+            const createdId = nextNodeId;
+            nextNodeId += 1;
+            nodeIds.set(node, createdId);
+            return createdId;
+        },
+        getSourceFiles() {
+            return sourceFiles;
+        },
+        getSymbolId(symbol) {
+            const cachedId = symbolIds.get(symbol);
+            if (cachedId !== undefined) {
+                return cachedId;
+            }
+            const createdId = nextSymbolId;
+            nextSymbolId += 1;
+            symbolIds.set(symbol, createdId);
+            return createdId;
+        },
+        traverse(node, visitor) {
+            traverseNode(node, visitor, context.isGeneratedNode);
+        },
+    };
+    return context;
+}