tsc-ts 0.0.8 → 0.0.10

package/src/compiler/thread-entry.ts

@@ -6,7 +6,7 @@ import { parentPort } from 'node:worker_threads';
 import { publish, sharesPublishedGraphs } from '@scriptc/threads';
 import { reserveNodeIds, shareNodeIds } from './ast.js';
 import type { OutputWriter } from './compile-program.js';
-import { useThreadTextCaches } from './diagnostics.js';
+import { type DiagnosticFormatOptions, formattedReports, useThreadTextCaches } from './diagnostics.js';
 import { compareReferencesOfThread, type ReferenceJob, referenceThreads } from './incremental.js';
 import {
   CheckerResult,
@@ -16,6 +16,7 @@ import {
   parallelCheck,
   recycleFiles,
 } from './parallel-check.js';
+import { emitFromQueue, parallelEmit, postedEmitResult } from './parallel-emit.js';
 import { type LoadMessage, parallelParse } from './parallel-parse.js';
 import type { ParseThread } from './parse-thread.js';
 import { useLazyJSDocTable } from './parser.js';
@@ -38,7 +39,7 @@ export interface ThreadDrivers {
 export type ThreadSpawn = (data: ThreadData) => Worker;
 
 /** The `workerData` of a thread of tsc-ts. */
-export type ThreadData = CheckerThreadData | ParseThreadData | ReferenceThreadData;
+export type ThreadData = CheckerThreadData | EmitThreadData | ParseThreadData | ReferenceThreadData;
 
 export interface CheckerThreadData {
   readonly kind: 'check';
@@ -54,6 +55,21 @@ export interface CheckerThreadData {
   readonly emits: boolean;
   readonly emitKinds: number[] | undefined;
   readonly checking: boolean;
+  readonly units: number[];
+  /** The main thread's report format (`formattedReports`), which the thread formats its diagnostics in. */
+  readonly reportFormat: DiagnosticFormatOptions | undefined;
+}
+
+export interface EmitThreadData {
+  readonly kind: 'emit';
+  /** The shared, published program. */
+  readonly program: Program;
+  readonly index: number;
+  readonly counter: SharedArrayBuffer;
+  readonly files: number[];
+  readonly kinds: number[];
+  readonly nodeIds: number;
+  readonly symbolIds: number;
 }
 
 export interface ParseThreadData {
@@ -75,7 +91,19 @@ export interface ReferenceThreadData {
  */
 export function startThreads(spawn: ThreadSpawn, drivers: ThreadDrivers, args: readonly string[]): void {
   parallelCheck.writer = drivers.outputWriter();
-  parallelCheck.spawn = (program, index, counter, order, nodeIds, symbolIds, reserved, emits, emitKinds, checking) =>
+  parallelCheck.spawn = (
+    program,
+    index,
+    counter,
+    order,
+    nodeIds,
+    symbolIds,
+    reserved,
+    emits,
+    emitKinds,
+    checking,
+    units,
+  ) =>
     spawn({
       kind: 'check',
       program,
@@ -89,8 +117,12 @@ export function startThreads(spawn: ThreadSpawn, drivers: ThreadDrivers, args: r
       emits,
       emitKinds,
       checking,
+      units,
+      reportFormat: formattedReports.format,
     });
   if (sharesPublishedGraphs) {
+    parallelEmit.spawn = (program, index, counter, files, kinds, nodeIds, symbolIds) =>
+      spawn({ kind: 'emit', program, index, counter, files, kinds, nodeIds, symbolIds });
     parallelParse.spawn = (configFileName, counter, index) =>
       spawn({ kind: 'parse', configFileName, args, counter, index });
     // The main thread compares the files a reference thread that failed did not.
@@ -109,6 +141,7 @@ export function runThread(data: unknown, drivers: ThreadDrivers): void {
   const kind = (data as { kind: string }).kind;
   if (kind === 'parse') runParseThread(data as ParseThreadData, drivers);
   else if (kind === 'references') runReferenceThread(data as ReferenceThreadData);
+  else if (kind === 'emit') runEmitThread(data as EmitThreadData, drivers);
   else runCheckerThread(data as CheckerThreadData, drivers);
 }
 
@@ -127,12 +160,36 @@ function runReferenceThread(data: ReferenceThreadData): void {
   mark('references compared');
 }
 
+/** An emit thread (parallel-emit.ts): emits JavaScript, without a checker. */
+function runEmitThread(job: EmitThreadData, drivers: ThreadDrivers): void {
+  setTimelineThread('e' + String(job.index));
+  mark('thread start');
+  // As on a checker thread, the shared program is never written.
+  reserveNodeIds(job.nodeIds);
+  reserveSymbolIds(job.symbolIds);
+  assignSymbolIdsAtCreation();
+  useLazyJSDocTable();
+  useThreadTextCaches();
+  const program = publish(job.program);
+  const result = emitFromQueue(
+    program,
+    job.index,
+    new Int32Array(job.counter),
+    job.files,
+    job.kinds,
+    drivers.outputWriter(),
+  );
+  parentPort!.postMessage(postedEmitResult(result, program));
+  mark('result posted');
+}
+
 /** A checker thread (parallel-check.ts). */
 function runCheckerThread(job: CheckerThreadData, drivers: ThreadDrivers): void {
   const startedAt = Date.now();
   setTimelineThread('c' + String(job.index));
   mark('thread start');
   parallelCheck.writer = drivers.outputWriter();
+  formattedReports.format = job.reportFormat;
   let program: Program | undefined = undefined;
   if (job.program !== undefined) {
     // The shared program is never written: new ids continue above its own, and lazily parsed JSDoc
@@ -161,6 +218,7 @@ function runCheckerThread(job: CheckerThreadData, drivers: ThreadDrivers): void
           job.emits,
           job.emitKinds,
           job.checking,
+          job.units,
         );
   // Packed results are copied: nothing this thread allocated stays reachable after it ends.
   if (packsResults) parentPort!.postMessage(packResult(result, program!));

package/src/compiler/tsc-build.ts

@@ -55,15 +55,20 @@ import {
   SystemFileSystem,
 } from './tsc-cli.js';
 import {
+  checkWhileThreadsEmit,
   emitFilesAndReportErrors,
+  emitKindsOf,
+  emitsOnThreads,
   exitStatusOf,
   rechecksOnThreads,
+  reportEmitAndErrors,
   Statistics,
   statisticsOf,
   SystemTimeStamps,
 } from './tsc-compile.js';
 import { sharesPublishedGraphs } from '@scriptc/threads';
 import { checkerThreads, parseThreads, shareWithCheckers, startParallelCheck } from './parallel-check.js';
+import { emitThreads } from './parallel-emit.js';
 import { LoadKind, ParseSession, clearPreparedFiles, parallelParse, reportPreparedFiles } from './parallel-parse.js';
 import { assignSymbolIdsAtCreation } from './symbol.js';
 
@@ -792,10 +797,58 @@ export class Orchestrator {
       });
       return true;
     }
+    if (mayUseThreads && this.emitsOnThreads(checked, oldSnapshot))
+      return this.checkWhileThreadsEmit(task, checked, times, oldSnapshot, then);
     this.emitAndReport(task, checked, times, oldSnapshot, undefined);
     return false;
   }
 
+  /**
+   * Whether `checkWhileThreadsEmit` builds the project of `checked`: one whose emit threads apply
+   * (`emitsOnThreads`), that emits every file (one without old build info, or one that is not incremental)
+   * and that emits enough for the threads (`emitThreads`).
+   */
+  private emitsOnThreads(checked: CheckedProgram, oldSnapshot: Snapshot | undefined): boolean {
+    const options = checked.program.options;
+    return (
+      emitsOnThreads(options) &&
+      (oldSnapshot === undefined || !isIncremental(options)) &&
+      emitThreads(checked.program, options.singleThreaded) > 0
+    );
+  }
+
+  /**
+   * The rest of `checkAndEmit` with one checker for a project that `emitsOnThreads` accepts, as `tsc -p` compiles
+   * (`compileWithEmitThreads`, tsc-compile.ts): this thread checks the program while emit threads emit its
+   * JavaScript, and the declaration thread its declarations where that pays (parallel-emit.ts). Where its pending
+   * emit leaves too little JavaScript for the threads (`emitDeclarationOnly`), this thread checks and emits it.
+   * Returns whether the threads emit, and then calls `then` once the project is emitted.
+   */
+  private checkWhileThreadsEmit(
+    task: BuildTask,
+    checked: CheckedProgram,
+    times: CompileTimes,
+    oldSnapshot: Snapshot | undefined,
+    then: () => void,
+  ): boolean {
+    const program = checked.program;
+    const options = program.options;
+    // The program is shared before its checker does more than merge the globals.
+    shareWithCheckers(checked);
+    const incrementalProgram = this.incrementalProgramOf(task, checked, times, oldSnapshot);
+    const emitKinds = emitKindsOf(incrementalProgram);
+    const threads = emitThreads(program, options.singleThreaded, emitKinds);
+    if (threads === 0) {
+      this.emitAndReport(task, checked, times, oldSnapshot, undefined, incrementalProgram);
+      return false;
+    }
+    checkWhileThreadsEmit(incrementalProgram, threads, emitKinds, (diagnostics) => {
+      this.emitAndReport(task, checked, times, oldSnapshot, undefined, incrementalProgram, diagnostics);
+      then();
+    });
+    return true;
+  }
+
   /**
    * The rest of `checkAndEmit` for a project with old build info on checker threads, as `tsc -p` rebuilds
    * (`recheckInParallel`, tsc-compile.ts): the program is shared with the threads first, then the
@@ -869,22 +922,23 @@ export class Orchestrator {
     oldSnapshot: Snapshot | undefined,
     /** The wall time of checker threads that checked the program, as reported. */
     parallelCheckTime: number | undefined,
-    /** The incremental program, where `recheckOnThreads` made it. */
+    /** The incremental program, where `recheckOnThreads` or `checkWhileThreadsEmit` made it. */
     made?: IncrementalProgram,
+    /** The program's diagnostics, where `checkWhileThreadsEmit` collected them. */
+    diagnostics?: Diagnostic[],
   ): void {
     const resolved = task.resolved!;
     const sys = this.sys;
     const program = checked.program;
     const incrementalProgram = made ?? this.incrementalProgramOf(task, checked, times, oldSnapshot);
 
-    const result = emitFilesAndReportErrors(
-      sys,
-      incrementalProgram,
-      new TaskDiagnosticReporter(task, this.reporter, sys, this.locale),
-      new QuietSummary(sys, {}, this.locale),
-      new TaskWriter(this, task),
-      this.locale,
-    );
+    const reporter = new TaskDiagnosticReporter(task, this.reporter, sys, this.locale);
+    const summary = new QuietSummary(sys, {}, this.locale);
+    const writer = new TaskWriter(this, task);
+    const result =
+      diagnostics === undefined
+        ? emitFilesAndReportErrors(sys, incrementalProgram, reporter, summary, writer, this.locale)
+        : reportEmitAndErrors(sys, incrementalProgram, diagnostics, reporter, summary, writer, this.locale);
     task.exitStatus = exitStatusOf(result);
     if (parallelCheckTime !== undefined) times.checkTime = parallelCheckTime;
     const options = program.options;

package/src/compiler/tsc-cli.ts

@@ -199,6 +199,11 @@ export class DiagnosticReporter {
     else this.sys.write(formatDiagnostic(diagnostic, this.format));
   }
 
+  /** The format `reportAll` writes diagnostics in, where it writes them plainly; undefined otherwise. */
+  plainFormat(): DiagnosticFormatOptions | undefined {
+    return this.quiet || this.pretty ? undefined : this.format;
+  }
+
   /** Writes the diagnostics at once: a write for each costs more than formatting it. */
   reportAll(diagnostics: readonly Diagnostic[]): void {
     if (this.quiet || diagnostics.length === 0) return;

package/src/compiler/tsc-compile.ts

@@ -11,9 +11,11 @@ import {
   getDiagnosticsOfProgram,
   OutputWriter,
   PlainProgram,
+  recordMetadataKinds,
 } from './compile-program.js';
-import type { Diagnostic, Locale } from './diagnostics.js';
-import { EmitResult } from './emitter.js';
+import { type Diagnostic, formattedReports, type Locale } from './diagnostics.js';
+import { EmitOnly, EmitResult } from './emitter.js';
+import { type CompilerOptions, getEmitDeclarations } from './options.js';
 import {
   FileBuildInfoReader,
   IncrementalProgram,
@@ -21,7 +23,21 @@ import {
   type Snapshot,
   TimeStampHost,
 } from './incremental.js';
-import { checkerThreads, shareWithCheckers, startParallelCheck, traceSingleChecker } from './parallel-check.js';
+import {
+  checkerThreads,
+  parallelCheck,
+  shareWithCheckers,
+  startParallelCheck,
+  traceSingleChecker,
+} from './parallel-check.js';
+import {
+  declarationThreadPays,
+  emitThreads,
+  startDeclarationErrorThread,
+  startDeclarationThread,
+  startMetadataEmit,
+  startParallelEmit,
+} from './parallel-emit.js';
 import { sharesPublishedGraphs } from '@scriptc/threads';
 import { getNormalizedAbsolutePath } from './path.js';
 import { sortAndDeduplicateDiagnostics } from './program.js';
@@ -122,6 +138,213 @@ export function compileThreads(_sys: System, work: CompileWork): number {
   return checkerThreads(options.checkers, options.singleThreaded, work.program);
 }
 
+/** The number of threads to emit JavaScript on while this thread checks (`compileWithEmitThreads`), or 0. */
+export function compileEmitThreads(work: CompileWork): number {
+  return emitThreads(work.program, work.program.options.singleThreaded);
+}
+
+/**
+ * Like `compile`, with this thread checking the program while `threads` threads emit its JavaScript
+ * (parallel-emit.ts); calls `done` with the exit status once it is emitted and reported. Returns
+ * false, and `compile` runs instead, where emit threads don't apply (`emitsOnThreads`) and for an
+ * incremental program with build info, whose rebuild emits what changed. An incremental program
+ * without build info emits every file, as its pending emit holds (`emitKindsOf`).
+ */
+export function compileWithEmitThreads(
+  sys: System,
+  work: CompileWork,
+  threads: number,
+  done: (status: ExitStatus) => void,
+): boolean {
+  const program = work.program;
+  if (!emitsOnThreads(program.options)) return false;
+  if (work.incremental && !checksIncrementalOnThreads(sys, program.commandLine.buildInfoFileName())) return false;
+  const times = new CompileTimes();
+  times.configTime = work.configTime;
+  times.parseTime = work.parseTime;
+  const bindStart = performance.now();
+  const checked = new CheckedProgram(program);
+  times.bindTime = performance.now() - bindStart;
+  // The program is shared before its checker does more than merge the globals.
+  shareWithCheckers(checked);
+  let compilerProgram: CompilerProgram;
+  if (work.incremental) {
+    const old = oldSnapshotOf(sys, work, times);
+    const changesStart = performance.now();
+    compilerProgram = new IncrementalProgram(checked, times, old, new SystemTimeStamps(sys));
+    times.changesComputeTime = performance.now() - changesStart;
+  } else compilerProgram = new PlainProgram(checked, times);
+  const report = (diagnostics: Diagnostic[]): void => {
+    const result = reportEmitAndErrors(
+      sys,
+      compilerProgram,
+      diagnostics,
+      work.reporter,
+      work.errorSummary,
+      new SystemWriter(sys),
+      outputLocale(program.options),
+    );
+    traceSingleChecker(checked);
+    done(emitStatusAndReportStatistics(sys, compilerProgram, result));
+  };
+  const emitKinds = emitKindsOf(compilerProgram);
+  if (emitKinds !== undefined) threads = emitThreads(program, program.options.singleThreaded, emitKinds);
+  if (threads > 0) checkWhileThreadsEmit(compilerProgram, threads, emitKinds, report);
+  else {
+    const diagnostics = getDiagnosticsOfProgram(compilerProgram, false);
+    mark('diagnostics collected');
+    report(diagnostics);
+  }
+  return true;
+}
+
+/**
+ * Whether emit threads (parallel-emit.ts) can emit a program with `options` while this thread checks it:
+ * not one that emits nothing or waits for its errors to emit (`noEmitOnError`), nor one that emits a
+ * single `outFile` from the whole program.
+ */
+export function emitsOnThreads(options: CompilerOptions): boolean {
+  return (
+    options.noEmit !== true &&
+    options.noEmitOnError !== true &&
+    options.listFilesOnly !== true &&
+    (options.outFile ?? '') === ''
+  );
+}
+
+/**
+ * What emit threads emit of each file of `program`, by file index (`emitsJavaScript`, parallel-emit.ts):
+ * for an incremental program that keeps incremental state, the emit pending before checking
+ * (`IncrementalProgram.emitKindsOnCheckers`), which checking only adds to and the program's emit
+ * completes; `undefined` where every file is emitted in full.
+ */
+export function emitKindsOf(program: CompilerProgram): number[] | undefined {
+  if (!(program instanceof IncrementalProgram) || !program.snapshot.canUseIncrementalState()) return undefined;
+  return program.emitKindsOnCheckers(program.program.getSourceFiles());
+}
+
+/**
+ * Checks `compilerProgram` on this thread while `threads` emit threads emit the JavaScript of its files that
+ * `emitKinds` selects, and the declaration thread their declarations where that pays; then calls `report`
+ * with the program's diagnostics, once the outputs of every thread arrived for the program's emit to complete
+ * (`PlainProgram.emit`, `IncrementalProgram.emit`). The program must be shared (`shareWithCheckers`).
+ */
+export function checkWhileThreadsEmit(
+  compilerProgram: CompilerProgram,
+  threads: number,
+  emitKinds: readonly number[] | undefined,
+  report: (diagnostics: Diagnostic[]) => void,
+): void {
+  const checked = compilerProgram.checked;
+  const program = checked.program;
+  let diagnostics: Diagnostic[] | undefined = undefined;
+  // The first wave of emit threads, and the declaration thread or the second wave.
+  let emitting = 2;
+  let declarations: (EmitResult | undefined)[] | undefined = undefined;
+  const reportOnce = (): void => {
+    if (diagnostics === undefined || emitting > 0) return;
+    if (declarations !== undefined) {
+      // The declaration thread emitted all of each decorator metadata file: its result is the file's emit.
+      for (const i of metadata) {
+        const result = declarations[i];
+        if (result === undefined) continue;
+        checked.emittedInParallel![i] = result;
+        declarations[i] = new EmitResult();
+      }
+      checked.declarationsEmittedAhead = declarations;
+    }
+    report(diagnostics);
+  };
+  const emitted = (): void => {
+    emitting--;
+    reportOnce();
+  };
+  const metadata = startParallelEmit(checked, threads, emitted, emitKinds);
+  // With declarations, the declaration thread also emits the files with decorator metadata.
+  if (getEmitDeclarations(program.options) && declarationThreadPays(1))
+    declarations = startDeclarationThread(checked, metadata, emitted, emitKinds);
+  const found = getDiagnosticsOfProgram(compilerProgram, false);
+  mark('diagnostics collected');
+  // Else they are emitted with the kinds this thread's checker gives, now that it checked.
+  if (declarations === undefined) {
+    if (metadata.length > 0) {
+      const files = program.getSourceFiles();
+      const kinds = recordMetadataKinds(
+        checked,
+        metadata.map((i) => files[i]!),
+      );
+      mark('metadata kinds recorded');
+      startMetadataEmit(checked, threads, metadata, kinds, emitted);
+    } else emitting--;
+  }
+  diagnostics = found;
+  reportOnce();
+}
+
+/**
+ * Like `compile` for a `noEmit` program with declarations, which reports the errors of declaration emit:
+ * this thread checks the program while the declaration thread (`startDeclarationErrorThread`) finds the
+ * declaration errors of every file, then reports both; calls `done` with the exit status. Returns false
+ * where the declaration thread doesn't apply, and `compile` runs instead: an incremental program, one
+ * that waits for its errors (`noEmitOnError`), a program that isn't shared with threads, or one where a
+ * declaration thread doesn't pay (`declarationThreadPays`).
+ */
+export function compileWithDeclarationThread(
+  sys: System,
+  work: CompileWork,
+  done: (status: ExitStatus) => void,
+): boolean {
+  const program = work.program;
+  const options = program.options;
+  if (
+    work.incremental ||
+    options.noEmit !== true ||
+    options.noEmitOnError === true ||
+    options.listFilesOnly === true ||
+    options.singleThreaded === true ||
+    !getEmitDeclarations(options) ||
+    parallelCheck.spawn === undefined ||
+    !sharesPublishedGraphs ||
+    !declarationThreadPays(1)
+  )
+    return false;
+  const times = new CompileTimes();
+  times.configTime = work.configTime;
+  times.parseTime = work.parseTime;
+  const bindStart = performance.now();
+  const checked = new CheckedProgram(program);
+  times.bindTime = performance.now() - bindStart;
+  shareWithCheckers(checked);
+  const compilerProgram = new PlainProgram(checked, times);
+  let diagnostics: Diagnostic[] | undefined = undefined;
+  let declaring = true;
+  const report = (): void => {
+    if (diagnostics === undefined || declaring) return;
+    const result = reportEmitAndErrors(
+      sys,
+      compilerProgram,
+      diagnostics,
+      work.reporter,
+      work.errorSummary,
+      new SystemWriter(sys),
+      outputLocale(options),
+    );
+    traceSingleChecker(checked);
+    done(emitStatusAndReportStatistics(sys, compilerProgram, result));
+  };
+  startDeclarationErrorThread(checked, (declarations) => {
+    // `PlainProgram.getDeclarationDiagnostics` reads them.
+    checked.declarationsInParallel = declarations;
+    declaring = false;
+    report();
+  });
+  // `PlainProgram.emit` reports the declaration errors once the thread has found them.
+  diagnostics = getDiagnosticsOfProgram(compilerProgram, false, true);
+  mark('diagnostics collected');
+  report();
+  return true;
+}
+
 /**
  * Like `compile`, with `threads` checker threads (parallel-check.ts): calls `done` with the exit
  * status once the threads have checked the program and it is emitted and reported.
@@ -137,6 +360,8 @@ export function compileInParallel(
   times.configTime = work.configTime;
   times.parseTime = work.parseTime;
   const bindStart = performance.now();
+  // The checker threads format their diagnostics in the format the reporter writes them in.
+  formattedReports.format = work.reporter.plainFormat();
   mark(`${threads} checkers`);
   const checked = new CheckedProgram(program);
   times.bindTime = performance.now() - bindStart;
@@ -176,6 +401,43 @@ export function compileInParallel(
   };
   const options = program.options;
   if (!checking && (options.noEmit === true || options.noEmitOnError === true)) return finish(0);
+  if (
+    sharesPublishedGraphs &&
+    checking &&
+    !work.incremental &&
+    getEmitDeclarations(options) &&
+    options.noEmit !== true &&
+    options.noEmitOnError !== true &&
+    options.composite !== true &&
+    (options.outFile ?? '') === '' &&
+    declarationThreadPays(threads)
+  ) {
+    // The checker threads emit JavaScript and the declaration thread declarations (parallel-emit.ts).
+    const kinds: number[] = [];
+    for (let i = 0; i < program.getSourceFiles().length; i++) kinds.push(EmitOnly.Js);
+    let pending = 2;
+    let checkTime = 0;
+    let declarations: (EmitResult | undefined)[] = [];
+    const joined = (): void => {
+      if (--pending > 0) return;
+      checked.javaScriptEmittedOnThreads = true;
+      checked.declarationsEmittedAhead = declarations;
+      finish(checkTime);
+    };
+    declarations = startDeclarationThread(checked, [], joined);
+    startParallelCheck(
+      checked,
+      threads,
+      (time) => {
+        checkTime = time;
+        joined();
+      },
+      true,
+      kinds,
+      checking,
+    );
+    return;
+  }
   startParallelCheck(checked, threads, finish, true, undefined, checking);
 }
 
@@ -285,6 +547,19 @@ export function emitFilesAndReportErrors(
 ): CompileResult {
   const diagnostics = getDiagnosticsOfProgram(program, false);
   mark('diagnostics collected');
+  return reportEmitAndErrors(sys, program, diagnostics, reporter, errorSummary, writer, locale);
+}
+
+/** The rest of `emitFilesAndReportErrors`, with the program's `diagnostics` collected. */
+export function reportEmitAndErrors(
+  sys: System,
+  program: CompilerProgram,
+  diagnostics: Diagnostic[],
+  reporter: DiagnosticReporter,
+  errorSummary: ErrorSummaryReporter,
+  writer: OutputWriter,
+  locale: Locale,
+): CompileResult {
   let emitResult = new EmitResult();
   emitResult.emitSkipped = true;
   if (program.options.listFilesOnly !== true) {

package/src/library/diagnostics.ts

@@ -70,3 +70,26 @@ export function programDiagnostics(
       return [];
   }
 }
+
+/**
+ * What `semantic` answers for each of `files` and what `global` answers, after checking `files` and
+ * no other file. Checking one file can add diagnostics located in another, so every file is checked
+ * before any file's diagnostics are collected. With every file of the program listed, the answers are
+ * those of the full check.
+ */
+export function checkedFileDiagnostics(
+  checked: CheckedProgram,
+  files: readonly SourceFile[],
+): { files: (readonly CompilerDiagnostic[])[]; global: readonly CompilerDiagnostic[] } {
+  for (const file of files) checked.getSemanticDiagnostics(file);
+  const program = checked.program;
+  const global = [
+    ...program.getConfigFileParsingDiagnostics(),
+    ...program.getProgramDiagnostics(),
+    ...checked.getGlobalDiagnostics(),
+  ];
+  return {
+    files: files.map((file) => checked.getSemanticDiagnostics(file)),
+    global: sortAndDeduplicateDiagnostics(global).filter((d) => d.file === undefined),
+  };
+}