tsc-ts 0.0.9 → 0.1.0

package/src/compiler/parallel-check.ts

@@ -33,7 +33,14 @@ import {
   type OutputWriter,
   ProgramEmitter,
 } from './compile-program.js';
-import { Diagnostic, DiagnosticFile, RepopulateInfo } from './diagnostics.js';
+import {
+  Diagnostic,
+  DiagnosticFile,
+  type DiagnosticFormatOptions,
+  formatDiagnostic,
+  formattedReports,
+  RepopulateInfo,
+} from './diagnostics.js';
 import { EmitOnly, EmitResult } from './emitter.js';
 import { getEmitDeclarations, isIncremental } from './options.js';
 import { DeclarationSignatureWriter } from './incremental.js';
@@ -45,6 +52,17 @@ import { lastSymbolIdValue } from './symbol.js';
 import { shareMergedGlobals } from './checker-symbols.js';
 import { readFileSync } from 'node:fs';
 import { availableParallelism, totalmem } from 'node:os';
+import {
+  forbiddenWords,
+  isForbidden,
+  maxSharingCheckers,
+  numberLogSize,
+  recordTableSize,
+  resultTableSize,
+  shareThreads,
+  stringLogSize,
+  type ThreadSharingData,
+} from './shared-results.js';
 
 /** With TSC_TS_CHECKERS_TRACE: the process's resident and peak resident set in MB (Linux), else 0. */
 export function residentMB(): number[] {
@@ -66,7 +84,8 @@ export function residentMB(): number[] {
  * the main thread emits the program (`checkersEmit`). `emitKinds`, by file index, is what the emit of
  * each file includes (an `EmitOnly`, or -1 for none) where not every output of every file is emitted
  * (an incremental program's rebuild); `undefined` for all of them. `units` are the statement ranges of
- * declaration files the order has positions for (`CheckPlan.units`).
+ * declaration files the order has positions for (`CheckPlan.units`). `globalsInFileDiagnostics` is the main
+ * thread's `CheckedProgram.globalsInFileDiagnostics`.
  */
 export type CheckerSpawn = (
   program: Program | undefined,
@@ -80,6 +99,8 @@ export type CheckerSpawn = (
   emitKinds: number[] | undefined,
   checking: boolean,
   units: number[],
+  globalsInFileDiagnostics: boolean,
+  sharing: ThreadSharingData | undefined,
 ) => Worker;
 
 export class ParallelCheck {
@@ -144,10 +165,13 @@ export const recycleFiles: number = Math.max(0, Number(process.env.TSC_TS_RECYCL
  * text (index, -1 when the program has the file), pos, end, code, category, message,
  * skippedOnNoEmit, the argument count and indices, its repopulate kind (0 for none) followed by the
  * module reference (index), mode and package name (index) of other kinds, then its message chain and
- * related information as lists. An emit result is emitSkipped, the emitted files, errors and
- * unsupported files as lists of indices, then its diagnostics and its declaration signatures as a list
- * of indices. `files` and `nums` are typed arrays, which postMessage copies as one block of memory
- * each; it copies an array of numbers element by element.
+ * related information as lists. A diagnostic of a reported list (the files' diagnostic and declaration
+ * diagnostic lists, the global diagnostics and an emit result's diagnostics) is followed by its text in
+ * the main thread's report format (`Diagnostic.formatted`, an index, -1 for none). An emit result is
+ * emitSkipped, the emitted files, errors and unsupported files as lists of indices, then its
+ * diagnostics and its declaration signatures as a list of indices. `files` and `nums` are typed
+ * arrays, which postMessage copies as one block of memory each; it copies an array of numbers element
+ * by element.
  */
 export type PackedResult = {
   readonly index: number;
@@ -167,7 +191,11 @@ class ResultPacker {
   readonly strs: string[] = [];
   private readonly indices = new Map<string, number>();
 
-  constructor(private readonly program: Program) {}
+  constructor(
+    private readonly program: Program,
+    /** The main thread's report format, which this thread formats the reported diagnostics in. */
+    private readonly format: DiagnosticFormatOptions | undefined,
+  ) {}
 
   private str(text: string): number {
     let k = this.indices.get(text);
@@ -184,6 +212,21 @@ class ResultPacker {
     for (const d of diagnostics) this.diagnostic(d);
   }
 
+  /** A list the main thread reports: each diagnostic with its text in the report format. */
+  reported(diagnostics: readonly Diagnostic[]): void {
+    const nums = this.nums;
+    const format = this.format;
+    nums.push(diagnostics.length);
+    for (const d of diagnostics) {
+      this.diagnostic(d);
+      if (format === undefined) nums.push(-1);
+      else {
+        nums.push(this.strs.length);
+        this.strs.push(formatDiagnostic(d, format));
+      }
+    }
+  }
+
   private strList(texts: readonly string[]): void {
     this.nums.push(texts.length);
     for (const text of texts) this.nums.push(this.str(text));
@@ -194,7 +237,7 @@ class ResultPacker {
     this.strList(result.emittedFiles);
     this.strList(result.errors);
     this.strList(result.unsupported);
-    this.list(result.diagnostics);
+    this.reported(result.diagnostics);
     this.strList(result.declarationSignatures);
     this.strList(result.heldOutputs);
   }
@@ -226,11 +269,11 @@ class ResultPacker {
 
 /** Packs `result` (on the checker thread) for `postMessage`. */
 export function packResult(result: CheckerResult, program: Program): PackedResult {
-  const packer = new ResultPacker(program);
-  for (const list of result.diagnostics) packer.list(list);
+  const packer = new ResultPacker(program, formattedReports.format);
+  for (const list of result.diagnostics) packer.reported(list);
   packer.nums.push(result.declarations.length);
-  for (const list of result.declarations) packer.list(list);
-  packer.list(result.globals);
+  for (const list of result.declarations) packer.reported(list);
+  packer.reported(result.globals);
   packer.nums.push(result.emits.length);
   for (const emit of result.emits) packer.emit(emit);
   return {
@@ -272,6 +315,19 @@ class ResultUnpacker {
     return result;
   }
 
+  /** A list `ResultPacker.reported` packed. */
+  reported(): Diagnostic[] {
+    const n = this.next();
+    const result: Diagnostic[] = [];
+    for (let k = 0; k < n; k++) {
+      const d = this.diagnostic();
+      const text = this.next();
+      if (text >= 0) d.formatted = this.packed.strs[text]!;
+      result.push(d);
+    }
+    return result;
+  }
+
   private diagnostic(): Diagnostic {
     const strs = this.packed.strs;
     const name = this.next();
@@ -325,7 +381,7 @@ class ResultUnpacker {
     this.strList(result.emittedFiles);
     this.strList(result.errors);
     this.strList(result.unsupported);
-    for (const d of this.list()) result.diagnostics.push(d);
+    for (const d of this.reported()) result.diagnostics.push(d);
     this.strList(result.declarationSignatures);
     this.strList(result.heldOutputs);
     return result;
@@ -339,11 +395,11 @@ export function unpackResult(
 ): CheckerResult {
   const unpacker = new ResultUnpacker(packed, program, files);
   const diagnostics: Diagnostic[][] = [];
-  for (let k = 0; k < packed.files.length; k++) diagnostics.push(unpacker.list());
+  for (let k = 0; k < packed.files.length; k++) diagnostics.push(unpacker.reported());
   const declarations: Diagnostic[][] = [];
   const nd = unpacker.count();
-  for (let k = 0; k < nd; k++) declarations.push(unpacker.list());
-  const globals = unpacker.list();
+  for (let k = 0; k < nd; k++) declarations.push(unpacker.reported());
+  const globals = unpacker.reported();
   const emits: EmitResult[] = [];
   const ne = unpacker.count();
   for (let k = 0; k < ne; k++) emits.push(unpacker.emit());
@@ -650,8 +706,8 @@ class CheckCosts {
     readonly libraries: number[][],
     /** What resolving a library costs a checker the first time (`libraryFirstUseShare` of the text it reaches), by index. */
     readonly libraryCost: number[],
-    /** The program files (indices) each file of `order` imports, by index. */
-    readonly imports: (number[] | undefined)[],
+    /** The program files (indices) each file imports (`ProcessedFiles.addedFiles`), by index. */
+    readonly imports: readonly (readonly number[])[],
   ) {}
 }
 
@@ -696,34 +752,18 @@ function checkCosts(checked: CheckedProgram, order: number[]): CheckCosts {
   }
   const length = textLengths(program);
   for (const i of order) cost[i] = length[i]!;
-  const indexOf = new Map<SourceFile, number>();
-  for (let i = 0; i < files.length; i++) indexOf.set(files[i]!, i);
-  // A file resolved by its own file name is that file (its path is the path of that name).
-  const byFileName = new Map<string, SourceFile>();
-  for (const file of files) byFileName.set(file.fileName, file);
   const checkedFile: boolean[] = [];
   for (let i = 0; i < files.length; i++) checkedFile.push(false);
   for (const i of order) checkedFile[i] = true;
   // Libraries: unchecked modules that are not default libraries (globals every checker has).
   const isLibrary = (i: number): boolean =>
     !checkedFile[i]! && !program.isSourceFileDefaultLibrary(files[i]!.path) && isExternalModuleFile(files[i]!);
-  const edges: (number[] | undefined)[] = [];
-  const edgesOf = (i: number): number[] => {
-    let result = edges[i];
-    if (result === undefined) {
-      result = [];
-      for (const target of program.getResolvedFilesOf(files[i]!, byFileName)) {
-        const k = indexOf.get(target);
-        if (k !== undefined && k !== i) result.push(k);
-      }
-      edges[i] = result;
-    }
-    return result;
-  };
+  // The files each file imports: those it added to the program (`ProcessedFiles.addedFiles`).
+  const edges = program.addedFiles();
   const importers = new Map<number, number>();
   for (const i of order) {
     const libraries: number[] = [];
-    for (const k of edgesOf(i)) if (isLibrary(k) && libraries.indexOf(k) < 0) libraries.push(k);
+    for (const k of edges[i]!) if (isLibrary(k) && libraries.indexOf(k) < 0) libraries.push(k);
     librariesOf[i] = libraries;
     for (const k of libraries) importers.set(k, (importers.get(k) ?? 0) + 1);
   }
@@ -738,7 +778,7 @@ function checkCosts(checked: CheckedProgram, order: number[]): CheckCosts {
     while (stack.length > 0) {
       const k = stack.pop()!;
       total += length[k]!;
-      for (const t of edgesOf(k))
+      for (const t of edges[k]!)
         if (!seen.has(t) && isLibrary(t)) {
           seen.add(t);
           stack.push(t);
@@ -1523,6 +1563,137 @@ export function traceSingleChecker(checked: CheckedProgram): void {
   );
 }
 
+/** The file a position of the order checks: a file index, or for a statement range, its file's. */
+function fileOfPosition(order: readonly number[], units: readonly number[], k: number): number {
+  const i = order[k]!;
+  return i >= 0 ? i : units[3 * (-1 - i)]!;
+}
+
+/**
+ * Hands position `k` of the order on to another checker (TSC_TS_SHARE). The handed-on positions are a list in
+ * `handoff`: a lock, their number, the number of checkers that may still hand positions on, then the positions.
+ */
+function handOff(handoff: Int32Array, k: number): void {
+  while (Atomics.compareExchange(handoff, 0, 0, 1) !== 0) {
+    // Another checker hands a position on or takes one.
+  }
+  const n = handoff[1]!;
+  handoff[3 + n] = k;
+  Atomics.store(handoff, 1, n + 1);
+  Atomics.store(handoff, 0, 0);
+  // Checkers with nothing else to check wait for handed-on positions.
+  Atomics.notify(handoff, 1);
+}
+
+/**
+ * Once checker `index` has no more positions of its own: a handed-on position it may check, waiting while other
+ * checkers may still hand some on; -1 when none is left for it.
+ */
+function waitForHandedOff(
+  handoff: Int32Array,
+  forbidden: Int32Array,
+  count: number,
+  order: readonly number[],
+  units: readonly number[],
+  index: number,
+): number {
+  Atomics.sub(handoff, 2, 1);
+  const start = performance.now();
+  for (;;) {
+    const n = Atomics.load(handoff, 1);
+    const k = takeHandedOff(handoff, forbidden, count, order, units, index);
+    if (k >= 0) {
+      // Checking it, this checker may hand positions on again.
+      Atomics.add(handoff, 2, 1);
+      return k;
+    }
+    // The main thread checks what is handed on later, as it does the files of a thread that failed.
+    if (Atomics.load(handoff, 2) === 0 || performance.now() - start > 2000) return -1;
+    Atomics.wait(handoff, 1, n, 1);
+  }
+}
+
+/**
+ * A handed-on position checker `index` of `count` may check, removed from the handed-on positions; -1 if there is
+ * none.
+ */
+function takeHandedOff(
+  handoff: Int32Array,
+  forbidden: Int32Array,
+  count: number,
+  order: readonly number[],
+  units: readonly number[],
+  index: number,
+): number {
+  if (Atomics.load(handoff, 1) === 0) return -1;
+  while (Atomics.compareExchange(handoff, 0, 0, 1) !== 0) {
+    // Another checker hands a position on or takes one.
+  }
+  const n = handoff[1]!;
+  let found = -1;
+  for (let j = 0; j < n; j++) {
+    const k = handoff[3 + j]!;
+    if (!isForbidden(forbidden, count, fileOfPosition(order, units, k), index)) {
+      found = k;
+      handoff[3 + j] = handoff[3 + n - 1]!;
+      Atomics.store(handoff, 1, n - 1);
+      break;
+    }
+  }
+  Atomics.store(handoff, 0, 0);
+  return found;
+}
+
+/** TSC_TS_SHARE: the sharing data of each of `count` checker threads. */
+function threadSharingOf(
+  count: number,
+  order: readonly number[],
+  units: readonly number[],
+  files: number,
+): ThreadSharingData[] {
+  const takers = new SharedArrayBuffer(4 * files);
+  const forbidden = new SharedArrayBuffer(4 * files * forbiddenWords(count));
+  const handoff = new SharedArrayBuffer(4 * (3 + order.length));
+  new Int32Array(handoff)[2] = count;
+  const taken = new Int32Array(takers);
+  taken.fill(-2);
+  for (let k = 0; k < order.length; k++) {
+    const i = order[k]!;
+    if (i >= 0) {
+      if (taken[i] === -2) taken[i] = 0;
+    } else taken[units[3 * (-1 - i)]!] = -1;
+  }
+  const typeTable = new SharedArrayBuffer(8 * resultTableSize);
+  const returnTable = new SharedArrayBuffer(8 * resultTableSize);
+  const numberLogs: SharedArrayBuffer[] = [];
+  const recordTables: SharedArrayBuffer[] = [];
+  const stringLogs: SharedArrayBuffer[] = [];
+  for (let i = 0; i < count; i++) {
+    numberLogs.push(new SharedArrayBuffer(4 * numberLogSize));
+    recordTables.push(new SharedArrayBuffer(8 * recordTableSize));
+    stringLogs.push(new SharedArrayBuffer(2 * stringLogSize));
+  }
+  const used = new SharedArrayBuffer(8 * count);
+  const data: ThreadSharingData[] = [];
+  for (let i = 0; i < count; i++)
+    data.push({
+      index: i,
+      count,
+      takers,
+      forbidden,
+      handoff,
+      typeTable,
+      returnTable,
+      nodeIds: lastNodeIdValue(),
+      symbolIds: lastSymbolIdValue(),
+      numberLogs,
+      recordTables,
+      stringLogs,
+      used,
+    });
+  return data;
+}
+
 /**
  * Checks files from the shared queue until it is empty; the main thread and checker threads alike.
  * A checker thread (`onMainThread` false) also sends back its global diagnostics. At `limit` files
@@ -1544,8 +1715,14 @@ export function checkFromQueue(
   emitKinds: readonly number[] | undefined = undefined,
   checking: boolean = true,
   units: readonly number[] = [],
+  sharing: ThreadSharingData | undefined = undefined,
 ): CheckerResult {
   const start = performance.now();
+  // TSC_TS_SHARE: each file's taker, which other checkers then take the results of its declarations from.
+  const takers = sharing === undefined ? undefined : new Int32Array(sharing.takers);
+  const forbidden = sharing === undefined ? undefined : new Int32Array(sharing.forbidden);
+  const handoff = sharing === undefined ? undefined : new Int32Array(sharing.handoff);
+  const sharingCount = sharing === undefined ? 0 : sharing.count;
   const readyAt = Date.now();
   const verbose = process.env.TSC_TS_CHECKERS_TRACE === '3';
   mark('checking');
@@ -1587,16 +1764,29 @@ export function checkFromQueue(
     if (limit > 0 && done.length >= limit) {
       more = true;
       left = reservedBy(index).splice(0);
+      // The thread that continues doesn't share results, so it hands nothing on.
+      if (handoff !== undefined) Atomics.sub(handoff, 2, 1);
       break;
     }
     // Except on checker 0, read the process's memory every 20 ms at most.
     if (retirement > 0 && performance.now() - memoryReadAt >= 20) {
       memoryReadAt = performance.now();
-      if (retires(counter, index, retirement)) break;
+      if (retires(counter, index, retirement)) {
+        if (handoff !== undefined) Atomics.sub(handoff, 2, 1);
+        break;
+      }
     }
-    const k = takePosition(counter, order.length, index, plan);
+    let k = handoff !== undefined ? takeHandedOff(handoff, forbidden!, sharingCount, order, units, index) : -1;
+    if (k < 0) k = takePosition(counter, order.length, index, plan);
+    if (k < 0 && handoff !== undefined) k = waitForHandedOff(handoff, forbidden!, sharingCount, order, units, index);
     if (k < 0) break;
     const i = order[k]!;
+    // A file this checker took results for before anyone took it goes to another checker.
+    if (forbidden !== undefined && i >= 0 && isForbidden(forbidden, sharingCount, i, index)) {
+      handOff(handoff!, k);
+      continue;
+    }
+    if (takers !== undefined && i >= 0) Atomics.store(takers, i, index + 1);
     if (i < 0) {
       // A statement range of a declaration file, which has nothing to emit.
       const u = -1 - i;
@@ -1642,24 +1832,39 @@ export function checkFromQueue(
     } else if (writer !== undefined) {
       const emitStart = timeline ? performance.now() : 0;
       const kind = (emitKinds === undefined ? EmitOnly.All : emitKinds[i]!) as EmitOnly;
+      // Global diagnostics found while emitting are not reported: the program collects them
+      // before it emits.
+      const checker = checked.checker;
       if (kind < 0) emits.push(new EmitResult());
       else if (signatures !== undefined) {
         signatures.file = files[i]!;
-        const result = emitter!.emit([files[i]!], kind, signatures);
+        const result = checker.withoutGlobalDiagnostics(() => emitter!.emit([files[i]!], kind, signatures));
         for (const s of signatures.take()) result.declarationSignatures.push(s);
         if (holding !== undefined) for (const o of holding.take()) result.heldOutputs.push(o);
         emits.push(result);
       } else {
-        const result = emitter!.emit([files[i]!], kind, writer);
+        const result = checker.withoutGlobalDiagnostics(() => emitter!.emit([files[i]!], kind, writer));
         if (holding !== undefined) for (const o of holding.take()) result.heldOutputs.push(o);
         emits.push(result);
       }
       if (timeline) markAt(emitStart, `emit ${(performance.now() - emitStart).toFixed(1)} ${files[i]!.fileName}`);
-    } else if (emitter !== undefined) declarations.push(declarationDiagnosticsOfFile(emitter, files[i]!));
+    } else if (emitter !== undefined)
+      declarations.push(
+        checked.checker.withoutGlobalDiagnostics(() => declarationDiagnosticsOfFile(emitter, files[i]!)),
+      );
+    // What emitting found and forgot can stay cached in this checker (a missing global type, an
+    // instantiation too deep), where checking a later file would report it: a new checker continues
+    // the schedule, as at the file limit.
+    if (checked.checker.forgottenGlobalDiagnostics() > 0) {
+      more = true;
+      left = reservedBy(index).splice(0);
+      break;
+    }
   }
   mark(`checked ${done.length} files, ${unitsDone.length} ranges`);
-  // The main thread reports its own global diagnostics (CheckedProgram.getGlobalDiagnostics).
-  const globals = onMainThread ? [] : checked.getGlobalDiagnostics().slice();
+  // On the main thread, those from before checking are the program's own (`ownGlobalDiagnostics`), and
+  // CheckedProgram.getGlobalDiagnostics deduplicates them with these.
+  const globals = (onMainThread ? checked.checker.getGlobalDiagnostics() : checked.getGlobalDiagnostics()).slice();
   let stats: number[] = [];
   if (process.env.TSC_TS_CHECKERS_TRACE !== undefined) {
     const cpu = process.threadCpuUsage();
@@ -1828,7 +2033,11 @@ export function shareWithCheckers(checked: CheckedProgram): void {
 /**
  * Checks `checked` on `checkers` threads and calls `done` once they are done. With `emits`, each thread
  * emits the files it checks (`emitKinds` limits what). With `checking` false, the threads only emit:
- * for a program whose report has no semantic diagnostics, so that no file is checked in full.
+ * for a program whose report has no semantic diagnostics, so that no file is checked in full. With
+ * `emitsTo`, the emit results go only there, by file index, and nothing else the threads find reaches
+ * the program: a declaration thread (parallel-emit.ts), while this thread's checker checks. With
+ * `declarationsTo`, the same holds for the declaration errors of a `noEmit` program
+ * (`checkersReportDeclarations`).
  */
 export function startParallelCheck(
   checked: CheckedProgram,
@@ -1837,6 +2046,8 @@ export function startParallelCheck(
   emits: boolean = true,
   emitKinds: number[] | undefined = undefined,
   checking: boolean = true,
+  emitsTo: (EmitResult | undefined)[] | undefined = undefined,
+  declarationsTo: (Diagnostic[] | undefined)[] | undefined = undefined,
 ): void {
   let count = checkers;
   const start = performance.now();
@@ -1899,11 +2110,22 @@ export function startParallelCheck(
   let remaining = count - firstThread;
   let ownDone = false;
   const finish = (): void => {
+    if (emitsTo !== undefined || declarationsTo !== undefined) {
+      mark('emitted on checker threads');
+      done(performance.now() - start);
+      return;
+    }
     if (checking) {
       joinRanges(checked, units, perUnit, perFile);
-      // A thread that failed may have taken files it never checked: check them here.
+      // A thread that failed may have taken files it never checked, and with TSC_TS_SHARE every checker left may
+      // have taken results for declarations of a file handed on: check them here.
+      let left = 0;
       for (const i of order)
-        if (i >= 0 && perFile[i] === undefined) perFile[i] = checked.unfilteredDiagnosticsOfFile(files[i]!);
+        if (i >= 0 && perFile[i] === undefined) {
+          perFile[i] = checked.unfilteredDiagnosticsOfFile(files[i]!);
+          left++;
+        }
+      if (trace && left > 0) process.stderr.write(`checkers: the main thread checked ${left} files\n`);
       checked.checkedInParallel = perFile;
     }
     mark('all checked');
@@ -1929,6 +2151,22 @@ export function startParallelCheck(
     done(performance.now() - start);
   };
   const record = (result: CheckerResult): void => {
+    if (declarationsTo !== undefined) {
+      for (let k = 0; k < result.declarations.length; k++) declarationsTo[result.files[k]!] = result.declarations[k]!;
+      if (trace)
+        process.stderr.write(
+          `checkers: emit-only thread ${result.index} found the declaration errors of ${result.declarations.length} files in ${result.checkTime.toFixed(1)}ms, done at ${(performance.now() - start).toFixed(1)}ms rss ${result.stats[7] ?? '?'}MB\n`,
+        );
+      return;
+    }
+    if (emitsTo !== undefined) {
+      for (let k = 0; k < result.emits.length; k++) emitsTo[result.files[k]!] = result.emits[k]!;
+      if (trace)
+        process.stderr.write(
+          `checkers: emit-only thread ${result.index} emitted ${result.emits.length} files in ${result.checkTime.toFixed(1)}ms, done at ${(performance.now() - start).toFixed(1)}ms rss ${result.stats[7] ?? '?'}MB\n`,
+        );
+      return;
+    }
     for (let k = 0; k < result.files.length; k++) perFile[result.files[k]!] = result.diagnostics[k]!;
     for (let k = 0; k < result.declarations.length; k++)
       perFileDeclarations[result.files[k]!] = result.declarations[k]!;
@@ -1950,6 +2188,17 @@ export function startParallelCheck(
     if (remaining === 0 && ownDone) finish();
   };
   const diagnosticFiles = new Map<string, DiagnosticFile>();
+  // TSC_TS_SHARE: checker threads share results (shared-results.ts).
+  const sharing =
+    shareThreads && shared && !mainChecks && count > 1 && count <= maxSharingCheckers
+      ? threadSharingOf(count, order, units, files.length)
+      : undefined;
+  const sharingStarted: boolean[] = [];
+  for (let i = 0; i < count; i++) sharingStarted.push(false);
+  const startSharingOf = (i: number): ThreadSharingData => {
+    sharingStarted[i] = true;
+    return sharing![i]!;
+  };
   const spawn = (i: number, reserved: number[]): void => {
     const worker = parallelCheck.spawn!(
       shared ? program : undefined,
@@ -1963,6 +2212,9 @@ export function startParallelCheck(
       emitKinds,
       checking,
       units,
+      checked.globalsInFileDiagnostics,
+      // A thread that continues another's index doesn't share.
+      reserved.length === 0 && sharing !== undefined && !sharingStarted[i] ? startSharingOf(i) : undefined,
     );
     worker.on('message', (message: unknown) => {
       mark(`result from c${i}`);
@@ -1979,7 +2231,8 @@ export function startParallelCheck(
       else threadDone();
     });
     worker.on('error', (error: unknown) => {
-      if (trace) process.stderr.write(`checkers: thread ${i} failed: ${String(error)}\n`);
+      // Sharing results (TSC_TS_SHARE) is still checked for such failures, which the main thread hides otherwise.
+      if (trace || shareThreads) process.stderr.write(`checkers: thread ${i} failed: ${String(error)}\n`);
       threadDone();
     });
   };
@@ -1991,10 +2244,31 @@ export function startParallelCheck(
   mark('reporting checker created');
   const emittedHere =
     !mainChecks && emitKinds === undefined ? emitUncheckedFiles(checked, order, emits) : new Map<number, EmitResult>();
-  if (mainChecks)
-    record(
-      checkFromQueue(checked, 0, new Int32Array(counter), order, epoch, true, 0, [], emits, emitKinds, checking, units),
+  if (mainChecks) {
+    // The program reports the global diagnostics this checker has before checking files as found before
+    // checking; those it finds checking them come with the threads' (`record`).
+    checked.ownGlobalDiagnostics = checked.checker.getGlobalDiagnostics().slice();
+    const own = checkFromQueue(
+      checked,
+      0,
+      new Int32Array(counter),
+      order,
+      epoch,
+      true,
+      0,
+      [],
+      emits,
+      emitKinds,
+      checking,
+      units,
     );
+    record(own);
+    // A thread continues where this checker stopped (`checkFromQueue`).
+    if (own.more) {
+      remaining++;
+      spawn(0, own.reserved);
+    }
+  }
   ownDone = true;
   if (remaining === 0) finish();
 }