@soundscript/soundscript 0.1.15 → 0.1.17

package/project-transform/src/checker/rules/relations.ts

@@ -99,6 +99,8 @@ interface TargetNewtypeIdentitySet {
   mode: 'intersection' | 'single' | 'union';
 }
 
+type CanonicalResultClassFamily = 'option' | 'result';
+
 type NominalIdentityLike = { symbol: ts.Symbol; typeArguments: readonly ts.Type[] };
 type NominalIdentitySet<TIdentity extends NominalIdentityLike> = {
   identities: readonly TIdentity[];
@@ -2513,7 +2515,8 @@ function isInstalledSoundStdlibSourceFile(sourceFile: ts.SourceFile): boolean {
   return normalizedFileName.includes('/node_modules/@soundscript/soundscript/') &&
     (
       normalizedFileName.endsWith('.d.ts') ||
-      normalizedFileName.endsWith('.sts')
+      normalizedFileName.endsWith('.sts') ||
+      normalizedFileName.endsWith('.sts.ts')
     );
 }
 
@@ -5609,10 +5612,24 @@ function classifyCurrentTypeNodeNominalClassRelation(
   sourceExpression?: ts.Expression,
   sourceTypeNode?: ts.TypeNode,
 ): RelationMismatch | undefined {
+  if (
+    sharesCanonicalResultClassFamily(context, sourceType, targetType) ||
+    sharesGenericAliasRelationFamily(context, sourceType, targetType) ||
+    sharesExactGenericClassIdentityFamilies(context, sourceType, targetType) ||
+    sharesEquivalentTargetClassIdentitySets(context, sourceType, targetType)
+  ) {
+    return undefined;
+  }
+
   const targetIdentitySet = getDeclaredClassIdentitySetFromTypeNode(context, targetTypeNode);
   if (!targetIdentitySet) {
     return undefined;
   }
+  const sourceFamily = getCanonicalResultClassFamilyForType(context, sourceType);
+  const targetFamily = getCanonicalResultClassFamilyForTargetIdentitySet(targetIdentitySet);
+  if (sourceFamily !== undefined && sourceFamily === targetFamily) {
+    return undefined;
+  }
 
   const sourceIdentitySet = getDeclaredClassIdentitySetFromTypeNode(context, sourceTypeNode) ??
     getDeclaredClassIdentitySetFromExpression(context, sourceExpression);
@@ -6019,6 +6036,12 @@ function classifySourceTypeAgainstTargetClassIdentitySet(
   targetType: ts.Type,
   targetIdentitySet: TargetClassIdentitySet,
 ): RelationMismatch | undefined {
+  const sourceFamily = getCanonicalResultClassFamilyForType(context, sourceType);
+  const targetFamily = getCanonicalResultClassFamilyForTargetIdentitySet(targetIdentitySet);
+  if (sourceFamily !== undefined && sourceFamily === targetFamily) {
+    return undefined;
+  }
+
   if (targetIdentitySet.mode === 'union') {
     const normalizedSourceType = getSafeNonNullableRelationType(context, sourceType);
     if ((normalizedSourceType.flags & ts.TypeFlags.Never) !== 0) {
@@ -6098,6 +6121,7 @@ function classifyUnsoundNominalClassRelation(
   targetType: ts.Type,
 ): RelationMismatch | undefined {
   if (
+    sharesCanonicalResultClassFamily(context, sourceType, targetType) ||
     sharesGenericAliasRelationFamily(context, sourceType, targetType) ||
     sharesExactGenericClassIdentityFamilies(context, sourceType, targetType) ||
     sharesEquivalentTargetClassIdentitySets(context, sourceType, targetType)
@@ -6194,6 +6218,7 @@ function classifyUnsoundGenericClassInstanceRelation(
   targetType: ts.Type,
 ): RelationMismatch | undefined {
   if (
+    sharesCanonicalResultClassFamily(context, sourceType, targetType) ||
     sharesGenericAliasRelationFamily(context, sourceType, targetType) ||
     sharesExactGenericClassIdentityFamilies(context, sourceType, targetType) ||
     sharesEquivalentTargetClassIdentitySets(context, sourceType, targetType)
@@ -6312,6 +6337,187 @@ function sharesEquivalentTargetClassIdentitySets(
     );
 }
 
+function isTrustedResultStdlibSourceFileName(fileName: string): boolean {
+  return /(?:^|[\\/])(?:index|result)(?:\.sts)?(?:\.d)?\.ts$/.test(fileName);
+}
+
+function getCanonicalResultClassFamilyForName(
+  name: string,
+): CanonicalResultClassFamily | undefined {
+  switch (name) {
+    case 'Err':
+    case 'Ok':
+    case 'Result':
+      return 'result';
+    case 'None':
+    case 'Option':
+    case 'Some':
+      return 'option';
+    default:
+      return undefined;
+  }
+}
+
+function getCanonicalResultClassFamilyForGenericRelationInfo(
+  info: GenericRelationTypeInfo,
+): CanonicalResultClassFamily | undefined {
+  const declarations = info.symbol.getDeclarations() ?? [];
+  if (!declarations.some((declaration) =>
+    isTrustedSoundLibSourceFile(declaration.getSourceFile()) &&
+    isTrustedResultStdlibSourceFileName(declaration.getSourceFile().fileName)
+  )) {
+    return undefined;
+  }
+
+  return getCanonicalResultClassFamilyForName(info.name);
+}
+
+function getCanonicalResultClassFamilyForIdentity(
+  identity: GenericClassIdentity,
+): CanonicalResultClassFamily | undefined {
+  const declarations = identity.symbol.getDeclarations() ?? [];
+  if (!declarations.some((declaration) =>
+    isTrustedSoundLibSourceFile(declaration.getSourceFile()) &&
+    isTrustedResultStdlibSourceFileName(declaration.getSourceFile().fileName)
+  )) {
+    return undefined;
+  }
+
+  return getCanonicalResultClassFamilyForName(identity.symbol.getName());
+}
+
+function getCanonicalResultClassFamilyForTargetIdentitySet(
+  identitySet: TargetClassIdentitySet,
+): CanonicalResultClassFamily | undefined {
+  let family: CanonicalResultClassFamily | undefined;
+  for (const identity of identitySet.identities) {
+    const identityFamily = getCanonicalResultClassFamilyForIdentity(identity);
+    if (!identityFamily) {
+      return undefined;
+    }
+    if (family && family !== identityFamily) {
+      return undefined;
+    }
+    family = identityFamily;
+  }
+
+  return family;
+}
+
+function getCanonicalResultClassFamilyForType(
+  context: AnalysisContext,
+  type: ts.Type,
+  visitedTypeIds: Set<number> = new Set(),
+): CanonicalResultClassFamily | undefined {
+  const normalizedType = getSafeNonNullableRelationType(context, type);
+  const rawTypeId = (normalizedType as ts.Type & { id?: number }).id;
+  let visitedTypeId: number | undefined;
+  if (typeof rawTypeId === 'number') {
+    if (visitedTypeIds.has(rawTypeId)) {
+      return undefined;
+    }
+    visitedTypeIds.add(rawTypeId);
+    visitedTypeId = rawTypeId;
+  }
+
+  try {
+    if ((normalizedType.flags & ts.TypeFlags.Union) !== 0) {
+      let family: CanonicalResultClassFamily | undefined;
+      let sawConstituent = false;
+      for (const constituentType of (normalizedType as ts.UnionType).types) {
+        const normalizedConstituentType = getSafeNonNullableRelationType(context, constituentType);
+        if ((normalizedConstituentType.flags & ts.TypeFlags.Never) !== 0) {
+          continue;
+        }
+        const constituentFamily = getCanonicalResultClassFamilyForType(
+          context,
+          normalizedConstituentType,
+          visitedTypeIds,
+        );
+        if (!constituentFamily) {
+          return undefined;
+        }
+        if (family && family !== constituentFamily) {
+          return undefined;
+        }
+        sawConstituent = true;
+        family = constituentFamily;
+      }
+
+      return sawConstituent ? family : undefined;
+    }
+
+    if ((normalizedType.flags & ts.TypeFlags.Intersection) !== 0) {
+      let family: CanonicalResultClassFamily | undefined;
+      for (const constituentType of (normalizedType as ts.IntersectionType).types) {
+        const constituentFamily = getCanonicalResultClassFamilyForType(
+          context,
+          constituentType,
+          visitedTypeIds,
+        );
+        if (!constituentFamily) {
+          continue;
+        }
+        if (family && family !== constituentFamily) {
+          return undefined;
+        }
+        family = constituentFamily;
+      }
+
+      return family;
+    }
+
+    const relationInfo = getGenericRelationTypeInfo(context, normalizedType);
+    const relationFamily = relationInfo
+      ? getCanonicalResultClassFamilyForGenericRelationInfo(relationInfo)
+      : undefined;
+    if (relationFamily) {
+      return relationFamily;
+    }
+
+    const directIdentity = getDirectClassIdentity(context, normalizedType);
+    const directFamily = directIdentity
+      ? getCanonicalResultClassFamilyForIdentity(directIdentity)
+      : undefined;
+    if (directFamily) {
+      return directFamily;
+    }
+
+    const identities = collectGenericClassIdentities(context, normalizedType);
+    if (identities.length === 0) {
+      return undefined;
+    }
+
+    let family: CanonicalResultClassFamily | undefined;
+    for (const identity of identities) {
+      const identityFamily = getCanonicalResultClassFamilyForIdentity(identity);
+      if (!identityFamily) {
+        return undefined;
+      }
+      if (family && family !== identityFamily) {
+        return undefined;
+      }
+      family = identityFamily;
+    }
+
+    return family;
+  } finally {
+    if (visitedTypeId !== undefined) {
+      visitedTypeIds.delete(visitedTypeId);
+    }
+  }
+}
+
+function sharesCanonicalResultClassFamily(
+  context: AnalysisContext,
+  sourceType: ts.Type,
+  targetType: ts.Type,
+): boolean {
+  const sourceFamily = getCanonicalResultClassFamilyForType(context, sourceType);
+  return sourceFamily !== undefined &&
+    sourceFamily === getCanonicalResultClassFamilyForType(context, targetType);
+}
+
 function getGenericParameterNames(
   symbol: ts.Symbol,
   arity: number,

package/project-transform/src/checker/rules/unsound_syntax.js

@@ -1583,9 +1583,6 @@ function getUnsupportedFeatureDiagnostic(context, node) {
             return unsupportedFeature(node.expression, 'prototypeMutation');
         }
     }
-    if (ts.isForInStatement(node)) {
-        return unsupportedFeature(node, 'forIn');
-    }
     if (ts.isLabeledStatement(node)) {
         return unsupportedFeature(node.label, 'labeledStatement');
     }

package/project-transform/src/checker/rules/unsound_syntax.ts

@@ -2381,10 +2381,6 @@ function getUnsupportedFeatureDiagnostic(
     }
   }
 
-  if (ts.isForInStatement(node)) {
-    return unsupportedFeature(node, 'forIn');
-  }
-
   if (ts.isLabeledStatement(node)) {
     return unsupportedFeature(node.label, 'labeledStatement');
   }

package/project-transform/src/cli.js

@@ -11,7 +11,7 @@ import { createTempDirectory, fileExistsSync, makeDirectory, readStdinText, remo
 import { materializeRuntimeGraph, } from './runtime/materialize.js';
 import { runProgram } from './run_program.js';
 import { projectEditorFile } from './editor_projection.js';
-export const VERSION = '0.1.15';
+export const VERSION = '0.1.17';
 const FINDINGS_EXIT_CODE = 1;
 const CLI_FAILURE_EXIT_CODE = 2;
 function createCliDiagnostic(code, message, filePath, details) {

package/project-transform/src/cli.ts

@@ -59,7 +59,7 @@ import {
 import { runProgram, type RunProgramOptions, type RunProgramResult } from './run_program.ts';
 import { projectEditorFile } from './editor_projection.ts';
 
-export const VERSION = '0.1.15';
+export const VERSION = '0.1.17';
 const FINDINGS_EXIT_CODE = 1;
 const CLI_FAILURE_EXIT_CODE = 2;
 

package/project-transform/src/compiler/compile_project.js

@@ -2,14 +2,14 @@ import ts from 'typescript';
 import { dirname, relative } from '../platform/path.js';
 import { createAnnotationLookup } from '../annotation_syntax.js';
 import { createSoundStdlibCompilerHost } from '../bundled/sound_stdlib.js';
-import { formatDiagnostics, getNodeDiagnosticRange, hasErrorDiagnostics, toMergedDiagnostic, } from '../checker/diagnostics.js';
+import { formatDiagnostics, getNodeDiagnosticRange, hasErrorDiagnostics, remapDiagnosticFilePaths, toMergedDiagnostic, } from '../checker/diagnostics.js';
 import { COMPILER_DIAGNOSTIC_CODES, COMPILER_DIAGNOSTIC_MESSAGES, } from '../checker/engine/diagnostic_codes.js';
 import { createAnalysisContext } from '../checker/engine/context.js';
 import { runSoundAnalysis } from '../checker/rules/index.js';
 import { runUniversalPolicyAnalysis } from '../checker/rules/universal.js';
 import { collectSoundscriptRootNames, getConfigFileParsingDiagnostics, loadConfig, } from '../config.js';
 import { createBuiltinExpandedProgram } from '../frontend/builtin_macro_support.js';
-import { getLineAndCharacterOfPosition, mapProgramEnclosingRangeToSource, toSourceFileName, } from '../frontend/project_frontend.js';
+import { getLineAndCharacterOfPosition, getPositionOfLineAndCharacter, mapProgramEnclosingRangeToSource, toSourceFileName, } from '../frontend/project_frontend.js';
 import { CompilerUnsupportedError } from './errors.js';
 import { lowerProgramToCompilerIR, validateHonestHeapBoundarySurfaces } from './lower.js';
 import { CompilerToolchainError, packageCompilerOutput, } from './toolchain.js';
@@ -57,6 +57,72 @@ function createCompilerDiagnosticForNode(node, overrides) {
         ...getNodeDiagnosticRange(node),
     };
 }
+function remapDiagnostics(diagnostics) {
+    return diagnostics.map((diagnostic) => remapDiagnosticFilePaths(diagnostic, toSourceFileName));
+}
+function hasRelatedInformation(diagnostic) {
+    return 'relatedInformation' in diagnostic;
+}
+function remapPreparedDiagnosticRange(diagnostic, preparedFile, diagnosticPreparedFiles) {
+    const remappedFilePath = diagnostic.filePath
+        ? toSourceFileName(diagnostic.filePath)
+        : diagnostic.filePath;
+    if (!preparedFile ||
+        !diagnostic.filePath ||
+        diagnostic.line === undefined ||
+        diagnostic.column === undefined) {
+        const remappedDiagnostic = {
+            ...diagnostic,
+            filePath: remappedFilePath,
+        };
+        if (hasRelatedInformation(diagnostic)) {
+            remappedDiagnostic.relatedInformation = diagnostic.relatedInformation?.map((relatedInformation) => remapPreparedDiagnosticRange(relatedInformation, relatedInformation.filePath
+                ? diagnosticPreparedFiles.get(toSourceFileName(relatedInformation.filePath))
+                : undefined, diagnosticPreparedFiles));
+        }
+        return remappedDiagnostic;
+    }
+    const programStart = getPositionOfLineAndCharacter(preparedFile.rewrittenText, diagnostic.line - 1, diagnostic.column - 1);
+    const programEnd = diagnostic.endLine !== undefined && diagnostic.endColumn !== undefined
+        ? getPositionOfLineAndCharacter(preparedFile.rewrittenText, diagnostic.endLine - 1, diagnostic.endColumn - 1)
+        : programStart;
+    const mappedRange = mapProgramEnclosingRangeToSource(preparedFile, programStart, programEnd);
+    const mappedStart = getLineAndCharacterOfPosition(preparedFile.originalText, mappedRange.start);
+    const mappedEnd = getLineAndCharacterOfPosition(preparedFile.originalText, mappedRange.end);
+    const remappedDiagnostic = {
+        ...diagnostic,
+        filePath: remappedFilePath,
+        line: mappedStart.line + 1,
+        column: mappedStart.character + 1,
+        endLine: mappedEnd.line + 1,
+        endColumn: mappedEnd.character + 1,
+    };
+    if (hasRelatedInformation(diagnostic)) {
+        remappedDiagnostic.relatedInformation = diagnostic.relatedInformation?.map((relatedInformation) => {
+            const relatedPreparedFile = relatedInformation.filePath
+                ? diagnosticPreparedFiles.get(toSourceFileName(relatedInformation.filePath))
+                : undefined;
+            return remapPreparedDiagnosticRange(relatedInformation, relatedPreparedFile, diagnosticPreparedFiles);
+        });
+    }
+    return remappedDiagnostic;
+}
+function remapSoundDiagnostics(diagnostics, diagnosticPreparedFiles) {
+    return diagnostics.map((diagnostic) => {
+        const preparedFile = diagnostic.filePath
+            ? diagnosticPreparedFiles.get(toSourceFileName(diagnostic.filePath))
+            : undefined;
+        return remapPreparedDiagnosticRange(diagnostic, preparedFile, diagnosticPreparedFiles);
+    });
+}
+function remapCompilerDiagnostics(diagnostics, diagnosticPreparedFiles) {
+    return diagnostics.map((diagnostic) => {
+        const preparedFile = diagnostic.filePath
+            ? diagnosticPreparedFiles.get(toSourceFileName(diagnostic.filePath))
+            : undefined;
+        return remapPreparedDiagnosticRange(diagnostic, preparedFile, diagnosticPreparedFiles);
+    });
+}
 function createProgram(options) {
     const loadedConfig = loadConfig(options.projectPath, { target: options.target });
     const soundscriptRootNames = collectSoundscriptRootNames(options.projectPath, loadedConfig);
@@ -78,7 +144,7 @@ function createProgram(options) {
         analysisPreparedProgram: expandedProgram.analysisPreparedProgram,
         diagnosticPreparedFiles: expandedProgram.diagnosticPreparedFiles,
         dispose: () => expandedProgram.dispose(),
-        frontendDiagnostics: expandedProgram.frontendDiagnostics(),
+        frontendDiagnostics: remapDiagnostics(expandedProgram.frontendDiagnostics()),
         program: expandedProgram.program,
         runtime: loadedConfig.runtime,
         tsDiagnosticPrograms: expandedProgram.tsDiagnosticPrograms,
@@ -193,7 +259,7 @@ function collectDiagnostics(analysisPreparedProgram, diagnosticPreparedFiles, pr
         workingDirectory,
         includeSourceFile: (sourceFile) => !sourceFile.isDeclarationFile,
     });
-    const universalDiagnostics = runUniversalPolicyAnalysis(analysisContext);
+    const universalDiagnostics = remapSoundDiagnostics(runUniversalPolicyAnalysis(analysisContext), diagnosticPreparedFiles);
     if (hasErrorDiagnostics(tsDiagnostics)) {
         return [...frontendDiagnostics, ...tsDiagnostics, ...universalDiagnostics];
     }
@@ -201,7 +267,7 @@ function collectDiagnostics(analysisPreparedProgram, diagnosticPreparedFiles, pr
         ...frontendDiagnostics,
         ...tsDiagnostics,
         ...universalDiagnostics,
-        ...runSoundAnalysis(analysisContext),
+        ...remapSoundDiagnostics(runSoundAnalysis(analysisContext), diagnosticPreparedFiles),
     ];
 }
 function findUnsupportedValueClass(program) {
@@ -242,13 +308,13 @@ export function compileProject(options) {
         }
         const unsupportedValueClass = findUnsupportedValueClass(program);
         if (unsupportedValueClass) {
-            const compilerDiagnostics = [
+            const compilerDiagnostics = remapCompilerDiagnostics([
                 createCompilerDiagnosticForNode(unsupportedValueClass, {
                     code: COMPILER_DIAGNOSTIC_CODES.valueClassesRequireJsEmit,
                     message: COMPILER_DIAGNOSTIC_MESSAGES.valueClassesRequireJsEmit,
                     hint: 'Use `soundscript build`, `soundscript node`, or another JS emit path for `#[value]`, or remove the annotation before compiling to Wasm.',
                 }),
-            ];
+            ], diagnosticPreparedFiles);
             return {
                 diagnostics: compilerDiagnostics,
                 output: formatDiagnostics(compilerDiagnostics, options.workingDirectory),
@@ -286,11 +352,11 @@ export function compileProject(options) {
                     hint: error.diagnosticHint,
                     notes: error.diagnosticNotes,
                 };
-                const compilerDiagnostics = [
+                const compilerDiagnostics = remapCompilerDiagnostics([
                     error.node
                         ? createCompilerDiagnosticForNode(error.node, diagnosticOverrides)
                         : createCompilerDiagnostic(options.projectPath, diagnosticOverrides),
-                ];
+                ], diagnosticPreparedFiles);
                 return {
                     diagnostics: compilerDiagnostics,
                     output: formatDiagnostics(compilerDiagnostics, options.workingDirectory),

package/project-transform/src/compiler/compile_project.ts

@@ -10,6 +10,7 @@ import {
   getNodeDiagnosticRange,
   hasErrorDiagnostics,
   type MergedDiagnostic,
+  remapDiagnosticFilePaths,
   toMergedDiagnostic,
 } from '../checker/diagnostics.ts';
 import {
@@ -29,6 +30,7 @@ import {
 import { createBuiltinExpandedProgram } from '../frontend/builtin_macro_support.ts';
 import {
   getLineAndCharacterOfPosition,
+  getPositionOfLineAndCharacter,
   mapProgramEnclosingRangeToSource,
   type PreparedSourceFile,
   toSourceFileName,
@@ -118,6 +120,115 @@ function createCompilerDiagnosticForNode(
   };
 }
 
+function remapDiagnostics<T extends MergedDiagnostic>(diagnostics: readonly T[]): T[] {
+  return diagnostics.map((diagnostic) => remapDiagnosticFilePaths(diagnostic, toSourceFileName));
+}
+
+function hasRelatedInformation(
+  diagnostic: MergedDiagnostic | DiagnosticRelatedInformation,
+): diagnostic is MergedDiagnostic {
+  return 'relatedInformation' in diagnostic;
+}
+
+function remapPreparedDiagnosticRange<T extends MergedDiagnostic | DiagnosticRelatedInformation>(
+  diagnostic: T,
+  preparedFile: PreparedSourceFile | undefined,
+  diagnosticPreparedFiles: ReadonlyMap<string, PreparedSourceFile>,
+): T {
+  const remappedFilePath = diagnostic.filePath
+    ? toSourceFileName(diagnostic.filePath)
+    : diagnostic.filePath;
+
+  if (
+    !preparedFile ||
+    !diagnostic.filePath ||
+    diagnostic.line === undefined ||
+    diagnostic.column === undefined
+  ) {
+    const remappedDiagnostic = {
+      ...diagnostic,
+      filePath: remappedFilePath,
+    } as T;
+    if (hasRelatedInformation(diagnostic)) {
+      (remappedDiagnostic as MergedDiagnostic).relatedInformation = diagnostic.relatedInformation?.map(
+        (relatedInformation) =>
+          remapPreparedDiagnosticRange(
+            relatedInformation,
+            relatedInformation.filePath
+              ? diagnosticPreparedFiles.get(toSourceFileName(relatedInformation.filePath))
+              : undefined,
+            diagnosticPreparedFiles,
+          ),
+      );
+    }
+    return remappedDiagnostic;
+  }
+
+  const programStart = getPositionOfLineAndCharacter(
+    preparedFile.rewrittenText,
+    diagnostic.line - 1,
+    diagnostic.column - 1,
+  );
+  const programEnd = diagnostic.endLine !== undefined && diagnostic.endColumn !== undefined
+    ? getPositionOfLineAndCharacter(
+      preparedFile.rewrittenText,
+      diagnostic.endLine - 1,
+      diagnostic.endColumn - 1,
+    )
+    : programStart;
+  const mappedRange = mapProgramEnclosingRangeToSource(preparedFile, programStart, programEnd);
+  const mappedStart = getLineAndCharacterOfPosition(preparedFile.originalText, mappedRange.start);
+  const mappedEnd = getLineAndCharacterOfPosition(preparedFile.originalText, mappedRange.end);
+
+  const remappedDiagnostic = {
+    ...diagnostic,
+    filePath: remappedFilePath,
+    line: mappedStart.line + 1,
+    column: mappedStart.character + 1,
+    endLine: mappedEnd.line + 1,
+    endColumn: mappedEnd.character + 1,
+  } as T;
+  if (hasRelatedInformation(diagnostic)) {
+    (remappedDiagnostic as MergedDiagnostic).relatedInformation = diagnostic.relatedInformation?.map(
+      (relatedInformation) => {
+        const relatedPreparedFile = relatedInformation.filePath
+          ? diagnosticPreparedFiles.get(toSourceFileName(relatedInformation.filePath))
+          : undefined;
+        return remapPreparedDiagnosticRange(
+          relatedInformation,
+          relatedPreparedFile,
+          diagnosticPreparedFiles,
+        );
+      },
+    );
+  }
+  return remappedDiagnostic;
+}
+
+function remapSoundDiagnostics<T extends MergedDiagnostic>(
+  diagnostics: readonly T[],
+  diagnosticPreparedFiles: ReadonlyMap<string, PreparedSourceFile>,
+): T[] {
+  return diagnostics.map((diagnostic) => {
+    const preparedFile = diagnostic.filePath
+      ? diagnosticPreparedFiles.get(toSourceFileName(diagnostic.filePath))
+      : undefined;
+    return remapPreparedDiagnosticRange(diagnostic, preparedFile, diagnosticPreparedFiles);
+  });
+}
+
+function remapCompilerDiagnostics<T extends MergedDiagnostic>(
+  diagnostics: readonly T[],
+  diagnosticPreparedFiles: ReadonlyMap<string, PreparedSourceFile>,
+): T[] {
+  return diagnostics.map((diagnostic) => {
+    const preparedFile = diagnostic.filePath
+      ? diagnosticPreparedFiles.get(toSourceFileName(diagnostic.filePath))
+      : undefined;
+    return remapPreparedDiagnosticRange(diagnostic, preparedFile, diagnosticPreparedFiles);
+  });
+}
+
 function createProgram(options: CompileProjectOptions): {
   analysisPreparedProgram: {
     toProgramFileName(fileName: string): string;
@@ -159,7 +270,7 @@ function createProgram(options: CompileProjectOptions): {
     analysisPreparedProgram: expandedProgram.analysisPreparedProgram,
     diagnosticPreparedFiles: expandedProgram.diagnosticPreparedFiles,
     dispose: () => expandedProgram.dispose(),
-    frontendDiagnostics: expandedProgram.frontendDiagnostics(),
+    frontendDiagnostics: remapDiagnostics(expandedProgram.frontendDiagnostics()),
     program: expandedProgram.program,
     runtime: loadedConfig.runtime,
     tsDiagnosticPrograms: expandedProgram.tsDiagnosticPrograms,
@@ -356,7 +467,10 @@ function collectDiagnostics(
     workingDirectory,
     includeSourceFile: (sourceFile) => !sourceFile.isDeclarationFile,
   });
-  const universalDiagnostics = runUniversalPolicyAnalysis(analysisContext);
+  const universalDiagnostics = remapSoundDiagnostics(
+    runUniversalPolicyAnalysis(analysisContext),
+    diagnosticPreparedFiles,
+  );
   if (hasErrorDiagnostics(tsDiagnostics)) {
     return [...frontendDiagnostics, ...tsDiagnostics, ...universalDiagnostics];
   }
@@ -365,7 +479,7 @@ function collectDiagnostics(
     ...frontendDiagnostics,
     ...tsDiagnostics,
     ...universalDiagnostics,
-    ...runSoundAnalysis(analysisContext),
+    ...remapSoundDiagnostics(runSoundAnalysis(analysisContext), diagnosticPreparedFiles),
   ];
 }
 
@@ -430,14 +544,14 @@ export function compileProject(options: CompileProjectOptions): CompileProjectRe
 
     const unsupportedValueClass = findUnsupportedValueClass(program);
     if (unsupportedValueClass) {
-      const compilerDiagnostics = [
+      const compilerDiagnostics = remapCompilerDiagnostics([
         createCompilerDiagnosticForNode(unsupportedValueClass, {
           code: COMPILER_DIAGNOSTIC_CODES.valueClassesRequireJsEmit,
           message: COMPILER_DIAGNOSTIC_MESSAGES.valueClassesRequireJsEmit,
           hint:
             'Use `soundscript build`, `soundscript node`, or another JS emit path for `#[value]`, or remove the annotation before compiling to Wasm.',
         }),
-      ];
+      ], diagnosticPreparedFiles);
       return {
         diagnostics: compilerDiagnostics,
         output: formatDiagnostics(compilerDiagnostics, options.workingDirectory),
@@ -475,11 +589,11 @@ export function compileProject(options: CompileProjectOptions): CompileProjectRe
           hint: error.diagnosticHint,
           notes: error.diagnosticNotes,
         };
-        const compilerDiagnostics = [
+        const compilerDiagnostics = remapCompilerDiagnostics([
           error.node
             ? createCompilerDiagnosticForNode(error.node, diagnosticOverrides)
             : createCompilerDiagnostic(options.projectPath, diagnosticOverrides),
-        ];
+        ], diagnosticPreparedFiles);
         return {
           diagnostics: compilerDiagnostics,
           output: formatDiagnostics(compilerDiagnostics, options.workingDirectory),