tsc-ts 0.0.8 → 0.0.10

package/src/compiler/diagnostics.ts

@@ -347,6 +347,11 @@ export class Diagnostic {
   readonly reportsDeprecated: boolean;
   skippedOnNoEmit = false;
   repopulateInfo: RepopulateInfo | undefined = undefined;
+  /**
+   * What `formatDiagnostic` gives for this diagnostic in `formattedReports.format`, where the checker
+   * thread that found it formatted it (`packResult`); `''` otherwise.
+   */
+  formatted = '';
 
   constructor(
     file: DiagnosticFile | undefined,
@@ -388,6 +393,7 @@ export class Diagnostic {
     result.relatedInformation = this.relatedInformation;
     result.skippedOnNoEmit = this.skippedOnNoEmit;
     result.repopulateInfo = this.repopulateInfo;
+    result.formatted = this.formatted;
     return result;
   }
 }
@@ -510,9 +516,13 @@ function compareRelatedInfo(a: readonly Diagnostic[], b: readonly Diagnostic[]):
 /** The order tsc reports diagnostics in: by file, position, code, arguments, then elaboration. */
 export function compareDiagnostics(a: Diagnostic, b: Diagnostic): number {
   if (a === b) return 0;
-  let c = compareCodePoints(fileNameOf(a), fileNameOf(b));
-  if (c !== 0) return c;
-  c = a.pos - b.pos;
+  const c = compareCodePoints(fileNameOf(a), fileNameOf(b));
+  return c !== 0 ? c : compareDiagnosticsInFile(a, b);
+}
+
+/** `compareDiagnostics` of two diagnostics whose files have the same name. */
+function compareDiagnosticsInFile(a: Diagnostic, b: Diagnostic): number {
+  let c = a.pos - b.pos;
   if (c !== 0) return c;
   c = a.end - b.end;
   if (c !== 0) return c;
@@ -527,6 +537,61 @@ export function compareDiagnostics(a: Diagnostic, b: Diagnostic): number {
   return compareRelatedInfo(a.relatedInformation, b.relatedInformation);
 }
 
+/**
+ * `diagnostics` in the order of `compareDiagnostics`, equal ones in their order in `diagnostics`. File
+ * names are compared once per pair of files rather than once per pair of diagnostics: the distinct
+ * files are sorted by name, and each diagnostic sorts by its file's place in that order, then by the
+ * rest of `compareDiagnostics`. A program's diagnostics come a file at a time, so the files are found
+ * from the runs of one file.
+ */
+export function sortDiagnostics(diagnostics: readonly Diagnostic[]): Diagnostic[] {
+  const n = diagnostics.length;
+  if (n < 2) return diagnostics.slice();
+  const fileIndices = new Map<DiagnosticFile | undefined, number>();
+  const files: (DiagnosticFile | undefined)[] = [];
+  const fileOf: number[] = [];
+  let last: DiagnosticFile | undefined = undefined;
+  let lastIndex = -1;
+  for (let i = 0; i < n; i++) {
+    const file = diagnostics[i]!.file;
+    if (lastIndex < 0 || file !== last) {
+      let k = fileIndices.get(file);
+      if (k === undefined) {
+        k = files.length;
+        fileIndices.set(file, k);
+        files.push(file);
+      }
+      last = file;
+      lastIndex = k;
+    }
+    fileOf.push(lastIndex);
+  }
+  // Files with the same name share a rank, as they compare equal.
+  const nameOf = (k: number): string => {
+    const file = files[k];
+    return file === undefined ? '' : file.fileName;
+  };
+  const byName: number[] = [];
+  for (let k = 0; k < files.length; k++) byName.push(k);
+  byName.sort((x, y) => compareCodePoints(nameOf(x), nameOf(y)));
+  const rank: number[] = [];
+  for (let k = 0; k < files.length; k++) rank.push(0);
+  for (let k = 1; k < byName.length; k++)
+    rank[byName[k]!] = rank[byName[k - 1]!]! + (nameOf(byName[k]!) === nameOf(byName[k - 1]!) ? 0 : 1);
+  const order: number[] = [];
+  for (let i = 0; i < n; i++) order.push(i);
+  order.sort((x, y) => {
+    const c = rank[fileOf[x]!]! - rank[fileOf[y]!]!;
+    if (c !== 0) return c;
+    const a = diagnostics[x]!;
+    const b = diagnostics[y]!;
+    return a === b ? 0 : compareDiagnosticsInFile(a, b);
+  });
+  const sorted: Diagnostic[] = [];
+  for (const i of order) sorted.push(diagnostics[i]!);
+  return sorted;
+}
+
 function equalChain(a: readonly Diagnostic[], b: readonly Diagnostic[]): boolean {
   if (a.length !== b.length) return false;
   for (let i = 0; i < a.length; i++) {
@@ -625,13 +690,29 @@ function formatDiagnosticIn(diagnostic: Diagnostic, fileName: string, options: D
   return result + flattenDiagnosticMessage(diagnostic, options.newLine, options.locale) + options.newLine;
 }
 
+/**
+ * The plain format the main thread reports a compilation's diagnostics in (`DiagnosticReporter.plainFormat`),
+ * which its checker threads receive a copy of and format the diagnostics they send back in
+ * (`Diagnostic.formatted`). Unset where diagnostics are reported with color and context, or not at all.
+ */
+export class FormattedReports {
+  format: DiagnosticFormatOptions | undefined = undefined;
+}
+
+export const formattedReports = new FormattedReports();
+
 /** `formatDiagnostic` of each diagnostic. */
 export function formatDiagnostics(diagnostics: readonly Diagnostic[], options: DiagnosticFormatOptions): string {
   let result = '';
+  const formatted = options === formattedReports.format;
   // Sorted diagnostics come a file at a time: the relative name of the last file is kept.
   let lastFile: DiagnosticFile | undefined = undefined;
   let lastName = '';
   for (const diagnostic of diagnostics) {
+    if (formatted && diagnostic.formatted !== '') {
+      result += diagnostic.formatted;
+      continue;
+    }
     const file = diagnostic.file;
     if (file !== undefined && file !== lastFile) {
       lastFile = file;

package/src/compiler/file-loader.ts

@@ -216,7 +216,7 @@ export class LoadedFile {
     readonly references: LoadedReference[],
     readonly resolutionsInFile: ModeAwareCache<ResolvedModule> | undefined,
     readonly typeResolutionsInFile: ModeAwareCache<ResolvedTypeReferenceDirective> | undefined,
-    readonly processingDiagnostics: ProcessingDiagnostic[],
+    readonly processingDiagnostics: readonly ProcessingDiagnostic[],
     readonly importHelpersImportSpecifier: StringLiteral | undefined,
     readonly jsxRuntimeImport: JsxRuntimeImport | undefined,
   ) {}
@@ -230,23 +230,34 @@ class SubTasksAhead {
   ) {}
 }
 
+/** Read in place of a task's lists it has not created. */
+const noParseTasks: readonly ParseTask[] = [];
+const noTraces: readonly MessageWithArgs[] = [];
+const noProcessingDiagnostics: readonly ProcessingDiagnostic[] = [];
+
+/**
+ * A file to load. Its lists are created on first use: most tasks never get sub-tasks, traces or processing
+ * diagnostics, and large programs create hundreds of thousands of tasks.
+ */
 class ParseTask {
   path = '';
   file: SourceFile | undefined = undefined;
   redirectedParseTask: ParseTask | undefined = undefined;
-  subTasks: ParseTask[] = [];
+  subTasks: ParseTask[] | undefined = undefined;
   loaded = false;
   startedSubTasks = false;
   metadata: SourceFileMetadata = libFileMetadata;
   resolutionsInFile: ModeAwareCache<ResolvedModule> | undefined = undefined;
-  readonly resolutionsTrace: MessageWithArgs[] = [];
+  resolutionsTrace: MessageWithArgs[] | undefined = undefined;
   typeResolutionsInFile: ModeAwareCache<ResolvedTypeReferenceDirective> | undefined = undefined;
-  readonly typeResolutionsTrace: MessageWithArgs[] = [];
-  readonly processingDiagnostics: ProcessingDiagnostic[] = [];
+  typeResolutionsTrace: MessageWithArgs[] | undefined = undefined;
+  processingDiagnostics: ProcessingDiagnostic[] | undefined = undefined;
   importHelpersImportSpecifier: StringLiteral | undefined = undefined;
   jsxRuntimeImport: JsxRuntimeImport | undefined = undefined;
   /** The task of the same file name that was loaded instead of this one. */
   loadedTask: ParseTask | undefined = undefined;
+  /** Whether an import or a type reference directive adds the file (`ProcessedFiles.addedFiles`). */
+  readonly byImport: boolean;
 
   constructor(
     readonly normalizedFilePath: string,
@@ -257,7 +268,10 @@ class ParseTask {
     /** A JavaScript file found in `node_modules`, loaded only within `maxNodeModuleJsDepth`. */
     readonly elideOnDepth: boolean,
     readonly packageId: PackageId | undefined,
-  ) {}
+  ) {
+    const kind = includeReason !== undefined ? includeReason.kind : -1;
+    this.byImport = kind === FileIncludeKind.Import || kind === FileIncludeKind.TypeReferenceDirective;
+  }
 
   addSubTask(
     fileName: string,
@@ -267,18 +281,40 @@ class ParseTask {
     elideOnDepth: boolean,
     packageId: PackageId | undefined,
   ): void {
-    this.subTasks.push(
+    (this.subTasks ??= []).push(
       new ParseTask(normalizePath(fileName), libFile, reason, false, increaseDepth, elideOnDepth, packageId),
     );
   }
+
+  addProcessingDiagnostic(diagnostic: ProcessingDiagnostic): void {
+    (this.processingDiagnostics ??= []).push(diagnostic);
+  }
+
+  /** Where module resolution traces go under `--traceResolution`; undefined without it. */
+  moduleTraces(trace: boolean): MessageWithArgs[] | undefined {
+    return trace ? (this.resolutionsTrace ??= []) : undefined;
+  }
+
+  /** Where type reference resolution traces go under `--traceResolution`; undefined without it. */
+  typeTraces(trace: boolean): MessageWithArgs[] | undefined {
+    return trace ? (this.typeResolutionsTrace ??= []) : undefined;
+  }
 }
 
+const noData: readonly ParseTaskData[] = [];
+
 /** The tasks of one path, by file name casing. */
 class ParseTaskData {
   readonly tasks = new Map<string, ParseTask>();
   lowestDepth = Number.MAX_SAFE_INTEGER;
   startedSubTasks = false;
   packageId: PackageId | undefined = undefined;
+  /** The index of this path's file in the program's files, once collected; -1 for none. */
+  index = -1;
+  /** For a deduplicated package's path, the tasks of the copy kept (`collect`). */
+  keptCopy: ParseTaskData | undefined = undefined;
+  /** The paths the file's imports and type reference directives add, once collected. */
+  added: readonly ParseTaskData[] = noData;
 
   constructor(task: ParseTask) {
     this.tasks.set(task.normalizedFilePath, task);
@@ -396,6 +432,11 @@ export class ProcessedFiles {
      * threads (`preparedPackageJsonLookups`); `undefined` where they may miss some.
      */
     readonly preparedPackageJsons: readonly PackageJsonLookup[] | undefined,
+    /**
+     * The files each file's imports and type reference directives added to the program, by index into
+     * `files`, without the file itself.
+     */
+    readonly addedFiles: readonly (readonly number[])[],
   ) {}
 }
 
@@ -423,6 +464,8 @@ export function withReplacedFile(processed: ProcessedFiles, file: SourceFile): P
     processed.redirectFilesByPath,
     processed.projectReferenceMapper,
     processed.preparedPackageJsons,
+    // The file has the same references (`canReplaceFile`), and keeps its index.
+    processed.addedFiles,
   );
 }
 
@@ -742,7 +785,7 @@ export class FileLoader {
       return undefined;
     }
     const references: LoadedReference[] = [];
-    for (const sub of task.subTasks) {
+    for (const sub of task.subTasks ?? noParseTasks) {
       references.push(
         new LoadedReference(
           sub.normalizedFilePath,
@@ -769,7 +812,7 @@ export class FileLoader {
       references,
       task.resolutionsInFile,
       task.typeResolutionsInFile,
-      task.processingDiagnostics,
+      task.processingDiagnostics ?? noProcessingDiagnostics,
       task.importHelpersImportSpecifier,
       task.jsxRuntimeImport,
     );
@@ -857,7 +900,7 @@ export class FileLoader {
       return;
     }
     const task = new ParseTask(absolute, undefined, reason, false, false, false, undefined);
-    task.processingDiagnostics.push(
+    task.addProcessingDiagnostic(
       ProcessingDiagnostic.explainingFileInclude('', reason, resolved.message, resolved.args),
     );
     this.rootTasks.push(task);
@@ -1031,7 +1074,7 @@ export class FileLoader {
       }
       if (!taskByFileName.startedSubTasks && loadSubTasks) {
         taskByFileName.startedSubTasks = true;
-        this.start(taskByFileName.subTasks, data.lowestDepth);
+        if (taskByFileName.subTasks !== undefined) this.start(taskByFileName.subTasks, data.lowestDepth);
       }
     }
   }
@@ -1073,7 +1116,7 @@ export class FileLoader {
     if (hasExtension(task.normalizedFilePath) && this.options.allowNonTsExtensions !== true) {
       const canonicalFileName = getCanonicalFileName(task.normalizedFilePath, fs.useCaseSensitiveFileNames);
       if (!this.isSupportedExtension(canonicalFileName)) {
-        task.processingDiagnostics.push(
+        task.addProcessingDiagnostic(
           hasJSFileExtension(canonicalFileName)
             ? ProcessingDiagnostic.explainingFileInclude(
                 '',
@@ -1122,7 +1165,7 @@ export class FileLoader {
         const reason = FileIncludeReason.reference(FileIncludeKind.LibReferenceDirective, task.path, i, undefined);
         const name = getLibFileName(file.libReferenceDirectives[i].fileName);
         if (name === '') {
-          task.processingDiagnostics.push(ProcessingDiagnostic.unknownReference(reason));
+          task.addProcessingDiagnostic(ProcessingDiagnostic.unknownReference(reason));
           continue;
         }
         const libFile = this.pathForLibFile(name);
@@ -1140,7 +1183,7 @@ export class FileLoader {
       this.subTasksAhead.delete(task.normalizedFilePath);
       task.subTasks = ahead.subTasks;
     } else task.subTasks = this.subTasksOf(loaded);
-    for (const diagnostic of loaded.processingDiagnostics) task.processingDiagnostics.push(diagnostic.copy());
+    for (const diagnostic of loaded.processingDiagnostics) task.addProcessingDiagnostic(diagnostic.copy());
     task.resolutionsInFile = loaded.resolutionsInFile;
     task.typeResolutionsInFile = loaded.typeResolutionsInFile;
     task.importHelpersImportSpecifier = loaded.importHelpersImportSpecifier;
@@ -1190,7 +1233,7 @@ export class FileLoader {
       reason,
     );
     if (typeof resolved !== 'string') {
-      task.processingDiagnostics.push(
+      task.addProcessingDiagnostic(
         ProcessingDiagnostic.explainingFileInclude('', reason, resolved.message, resolved.args),
       );
       return;
@@ -1216,7 +1259,7 @@ export class FileLoader {
         containingFile,
         mode,
         redirect?.resolved,
-        task.typeResolutionsTrace,
+        task.typeTraces(this.options.traceResolution === true),
       );
       resolutions.set(modeAwareKey(reference.fileName, mode), resolved);
       const reason = FileIncludeReason.reference(FileIncludeKind.TypeReferenceDirective, task.path, i, undefined);
@@ -1230,7 +1273,7 @@ export class FileLoader {
           resolved.packageId,
         );
       } else {
-        task.processingDiagnostics.push(ProcessingDiagnostic.unknownReference(reason));
+        task.addProcessingDiagnostic(ProcessingDiagnostic.unknownReference(reason));
       }
     }
     task.typeResolutionsInFile = resolutions;
@@ -1247,7 +1290,7 @@ export class FileLoader {
         task.normalizedFilePath,
         ModuleKind.None,
         undefined,
-        task.typeResolutionsTrace,
+        task.typeTraces(this.options.traceResolution === true),
       );
       resolutions.set(modeAwareKey(name, ModuleKind.None), resolved);
       if (resolved.resolvedFileName !== '') {
@@ -1260,7 +1303,7 @@ export class FileLoader {
           resolved.packageId,
         );
       } else {
-        task.processingDiagnostics.push(
+        task.addProcessingDiagnostic(
           ProcessingDiagnostic.explainingFileInclude(
             '',
             FileIncludeReason.automaticTypeDirective(name, undefined),
@@ -1308,7 +1351,7 @@ export class FileLoader {
         containingFile,
         mode,
         redirect?.resolved,
-        task.resolutionsTrace,
+        task.moduleTraces(this.options.traceResolution === true),
       );
       resolutions.set(modeAwareKey(moduleName, mode), resolved);
       const resolvedFileName = resolved.resolvedFileName;
@@ -1370,16 +1413,24 @@ export class FileLoader {
     const packageIdToSourceFile = new Map<string, SourceFile>();
     const checkCasing = this.options.forceConsistentCasingInFileNames !== false;
     const seen = new Map<ParseTaskData, string>();
-
-    const collectFiles = (tasks: readonly ParseTask[]): void => {
+    // The paths each file's imports and type reference directives add (the tasks of each path), for
+    // `ProcessedFiles.addedFiles`: recorded while collecting visits them, as their files are only known
+    // once every file is collected.
+    const fileData: ParseTaskData[] = [];
+    const libData = new Map<SourceFile, ParseTaskData>();
+    const packageIdToData = new Map<string, ParseTaskData>();
+
+    const collectFiles = (tasks: readonly ParseTask[], added: ParseTaskData[] | undefined): void => {
       for (let task of tasks) {
         const includeReason = task.includeReason;
+        const byImport = task.byImport;
         // Automatic type directive tasks are an implementation detail, not a reason.
         if (task.redirectedParseTask === undefined && !task.isForAutomaticTypeDirective) {
           if (task.loadedTask !== undefined) task = task.loadedTask;
           if (includeReason !== undefined) addIncludeReason(includeProcessor, task, includeReason);
         }
         const data = this.taskDataByPath.get(task.path);
+        if (added !== undefined && data !== undefined && byImport) added.push(data);
         if (!task.loaded || data === undefined) continue;
 
         const checkedName = seen.get(data);
@@ -1412,8 +1463,8 @@ export class FileLoader {
           }
         }
 
-        for (const trace of task.typeResolutionsTrace) host.trace(trace);
-        for (const trace of task.resolutionsTrace) host.trace(trace);
+        for (const trace of task.typeResolutionsTrace ?? noTraces) host.trace(trace);
+        for (const trace of task.resolutionsTrace ?? noTraces) host.trace(trace);
 
         const file = task.file;
         const packageId = data.packageId;
@@ -1434,13 +1485,18 @@ export class FileLoader {
               ),
             );
             filesByPath.set(task.path, packageIdFile);
+            data.keptCopy = packageIdToData.get(key);
             if (data.lowestDepth > 0) sourceFilesFoundSearchingNodeModules.add(task.path);
             continue;
           }
-          if (file !== undefined) packageIdToSourceFile.set(key, file);
+          if (file !== undefined) {
+            packageIdToSourceFile.set(key, file);
+            packageIdToData.set(key, data);
+          }
         }
 
-        if (task.subTasks.length > 0) collectFiles(task.subTasks);
+        let own: ParseTaskData[] | undefined = undefined;
+        if (task.subTasks !== undefined && task.subTasks.length > 0) collectFiles(task.subTasks, (own = []));
 
         const redirected = task.redirectedParseTask;
         if (redirected !== undefined) {
@@ -1449,21 +1505,26 @@ export class FileLoader {
         }
         if (task.isForAutomaticTypeDirective) {
           typeResolutionsInFile.set(task.path, task.typeResolutionsInFile);
-          for (const diagnostic of task.processingDiagnostics) includeProcessor.addProcessingDiagnostic(diagnostic);
+          for (const diagnostic of task.processingDiagnostics ?? noProcessingDiagnostics)
+            includeProcessor.addProcessingDiagnostic(diagnostic);
           continue;
         }
         const path = task.path;
-        for (const diagnostic of task.processingDiagnostics) includeProcessor.addProcessingDiagnostic(diagnostic);
+        for (const diagnostic of task.processingDiagnostics ?? noProcessingDiagnostics)
+          includeProcessor.addProcessingDiagnostic(diagnostic);
         if (file === undefined) {
           missingFiles.push(task.normalizedFilePath);
           continue;
         }
         if (task.libFile !== undefined) {
           libFiles.push(file);
+          libData.set(file, data);
           libFilesByPath.set(path, task.libFile);
         } else {
           files.push(file);
+          fileData.push(data);
         }
+        if (own !== undefined) data.added = own;
         filesByPath.set(path, file);
         resolvedModules.set(path, task.resolutionsInFile);
         typeResolutionsInFile.set(path, task.typeResolutionsInFile);
@@ -1475,13 +1536,28 @@ export class FileLoader {
         if (data.lowestDepth > 0) sourceFilesFoundSearchingNodeModules.add(path);
       }
     };
-    collectFiles(this.rootTasks);
+    collectFiles(this.rootTasks, undefined);
 
     const priorities = new Map<SourceFile, number>();
     for (const file of libFiles) priorities.set(file, this.libFilePriority(file));
     libFiles.sort((a, b) => (priorities.get(a) ?? 0) - (priorities.get(b) ?? 0));
     const allFiles = [...libFiles, ...files];
     for (const redirect of redirectFilesByPath.values()) redirect.index += libFiles.length;
+    // The files a file adds, without reading its resolutions again or looking up their paths.
+    const dataOfFiles: ParseTaskData[] = [];
+    for (const file of libFiles) dataOfFiles.push(libData.get(file)!);
+    for (const data of fileData) dataOfFiles.push(data);
+    for (let i = 0; i < dataOfFiles.length; i++) dataOfFiles[i]!.index = i;
+    const addedFiles: number[][] = [];
+    for (let i = 0; i < dataOfFiles.length; i++) {
+      const added: number[] = [];
+      for (const data of dataOfFiles[i]!.added) {
+        const kept = data.keptCopy;
+        const k = kept !== undefined ? kept.index : data.index;
+        if (k >= 0 && k !== i) added.push(k);
+      }
+      addedFiles.push(added);
+    }
 
     const keys = [...this.libResolutions.keys()].sort();
     for (const key of keys) {
@@ -1511,6 +1587,7 @@ export class FileLoader {
       redirectFilesByPath,
       this.mapper,
       this.tookPreparedResolutions ? preparedPackageJsonLookups() : noPackageJsonLookups,
+      addedFiles,
     );
   }
 }

package/src/compiler/incremental.ts

@@ -1864,8 +1864,21 @@ class EmitFilesHandler {
       const files = program.program.getSourceFiles();
       const emittedOnCheckers = this.emittedOnCheckers();
       const wrapped = this.wrap(writer);
-      const result =
-        emittedOnCheckers.size === 0
+      const ahead = this.declarationsEmittedAhead();
+      const result = program.checked.javaScriptEmittedOnThreads
+        ? combineEmitResults(
+            files.map((file) =>
+              this.emitAfterEmitThreads(
+                file,
+                EmitOnly.All,
+                emittedOnCheckers.get(file),
+                ahead.get(file),
+                writer,
+                wrapped,
+              ),
+            ),
+          )
+        : emittedOnCheckers.size === 0
           ? program.emitter.emit(files, EmitOnly.All, wrapped)
           : combineEmitResults(
               files.map((file) => {
@@ -1901,20 +1914,76 @@ class EmitFilesHandler {
   /**
    * The emit results of the files checker threads emitted right after checking them (parallel-check.ts),
    * which are not emitted again here. Checker threads emit every file of a program without old build
-   * info, with the outputs its options select, as its pending emit asks.
+   * info, with the outputs its options select, as its pending emit asks. Emit threads emit only the
+   * JavaScript of the files (`javaScriptEmittedOnThreads`, `emitAfterEmitThreads`).
    */
   private emittedOnCheckers(): Map<SourceFile, EmitResult> {
+    return this.byFile(this.program.checked.emittedInParallel);
+  }
+
+  /** The declaration emit of the files the declaration thread emitted (parallel-emit.ts). */
+  private declarationsEmittedAhead(): Map<SourceFile, EmitResult> {
+    return this.byFile(this.program.checked.declarationsEmittedAhead);
+  }
+
+  /** The results of `results`, by file index, by file. */
+  private byFile(results: readonly (EmitResult | undefined)[] | undefined): Map<SourceFile, EmitResult> {
     const result = new Map<SourceFile, EmitResult>();
-    const emitted = this.program.checked.emittedInParallel;
-    if (emitted === undefined) return result;
+    if (results === undefined) return result;
     const files = this.program.program.getSourceFiles();
     for (let i = 0; i < files.length; i++) {
-      const fileResult = emitted[i];
+      const fileResult = results[i];
       if (fileResult !== undefined) result.set(files[i]!, fileResult);
     }
     return result;
   }
 
+  /**
+   * The emit of `file` with `emitOnly` where emit threads emitted the JavaScript of the program's files
+   * while this thread checked it (`javaScriptEmittedOnThreads`, parallel-emit.ts): the outputs an emit thread
+   * emitted of its JavaScript (`javaScript`) and the declaration thread of its declarations (`declarations`),
+   * and the rest emitted here. A file no thread emitted is emitted here as without the threads.
+   */
+  private emitAfterEmitThreads(
+    file: SourceFile,
+    emitOnly: EmitOnly,
+    javaScript: EmitResult | undefined,
+    declarations: EmitResult | undefined,
+    writer: OutputWriter,
+    wrapped: OutputWriter,
+  ): EmitResult {
+    const program = this.program;
+    if (wrapped instanceof SignatureRecordingWriter) wrapped.file = file;
+    if (javaScript === undefined && declarations === undefined) return program.emitter.emit([file], emitOnly, wrapped);
+    const results: EmitResult[] = [];
+    if (emitOnly !== EmitOnly.Dts)
+      results.push(
+        javaScript !== undefined
+          ? this.writeThreadOutputs(file, javaScript, writer)
+          : program.emitter.emit([file], EmitOnly.Js, writer),
+      );
+    if (emitOnly !== EmitOnly.Js && getEmitDeclarations(program.snapshot.options))
+      results.push(
+        declarations !== undefined
+          ? this.writeThreadOutputs(file, declarations, writer)
+          : program.emitter.emit([file], EmitOnly.Dts, wrapped),
+      );
+    return combineEmitResults(results);
+  }
+
+  /**
+   * Writes the outputs a thread emitted for `file` with `writer`, as this thread would have written them:
+   * its declaration signatures are recorded (`recordDeclarationSignatures`), and the unchanged declaration
+   * files of a composite program are left unwritten.
+   */
+  private writeThreadOutputs(file: SourceFile, emitted: EmitResult, writer: OutputWriter): EmitResult {
+    const skips = this.recordDeclarationSignatures(file, emitted.declarationSignatures);
+    return writeHeldOutputs(
+      emitted,
+      skips === undefined ? writer : new HeldDeclarationWriter(writer, skips, this.program.host),
+    );
+  }
+
   /** Records declaration signatures when declarations are emitted. */
   private wrap(writer: OutputWriter): OutputWriter {
     return getEmitDeclarations(this.program.snapshot.options) ? new SignatureRecordingWriter(this, writer) : writer;
@@ -1926,6 +1995,7 @@ class EmitFilesHandler {
     collectAllAffectedFiles(program);
     const wrapped = this.wrap(writer);
     const emittedOnCheckers = this.emittedOnCheckers();
+    const ahead = this.declarationsEmittedAhead();
     for (const [path, emitKind] of snapshot.affectedFilesPendingEmit) {
       const affectedFile = program.program.getSourceFileByPath(path);
       if (affectedFile === undefined || !program.program.sourceFileMayBeEmitted(affectedFile, false)) {
@@ -1939,13 +2009,10 @@ class EmitFilesHandler {
       if (!this.isForDtsErrors) {
         const emitOnly = emitOnlyOfPendingKind(pendingKind);
         const emitted = emittedOnCheckers.get(affectedFile);
-        if (emitted !== undefined) {
-          const skips = this.recordDeclarationSignatures(affectedFile, emitted.declarationSignatures);
-          result = writeHeldOutputs(
-            emitted,
-            skips === undefined ? writer : new HeldDeclarationWriter(writer, skips, program.host),
-          );
-        } else {
+        if (program.checked.javaScriptEmittedOnThreads)
+          result = this.emitAfterEmitThreads(affectedFile, emitOnly, emitted, ahead.get(affectedFile), writer, wrapped);
+        else if (emitted !== undefined) result = this.writeThreadOutputs(affectedFile, emitted, writer);
+        else {
           if (wrapped instanceof SignatureRecordingWriter) wrapped.file = affectedFile;
           result = program.emitter.emit([affectedFile], emitOnly, wrapped);
         }

package/src/compiler/link-tables.ts

@@ -169,6 +169,38 @@ export class ClusteredIntLinkTable {
   }
 }
 
+/** Ids in pages of `IdSetPaging.Ids` ids, one bit each; a page is created by the first id added to it. */
+export class PagedIdSet {
+  readonly pages: (Int32Array | undefined)[] = [];
+
+  has(id: number): boolean {
+    const page = this.pages[id >> IdSetPaging.Bits];
+    return page !== undefined && (page[(id >> 5) & IdSetPaging.WordMask]! & (1 << (id & 31))) !== 0;
+  }
+
+  add(id: number): void {
+    const index = id >> IdSetPaging.Bits;
+    let page = this.pages[index];
+    if (page === undefined) {
+      while (this.pages.length <= index) this.pages.push(undefined);
+      page = new Int32Array(IdSetPaging.Words);
+      this.pages[index] = page;
+    }
+    page[(id >> 5) & IdSetPaging.WordMask] |= 1 << (id & 31);
+  }
+
+  clear(): void {
+    this.pages.length = 0;
+  }
+}
+
+/** `PagedIdSet` pages: 8192 ids in 256 words. */
+const enum IdSetPaging {
+  Bits = 13,
+  Words = 1 << (Bits - 5),
+  WordMask = Words - 1,
+}
+
 /** The number of set bits of a 32-bit value. */
 function bitCount(x: number): number {
   x = x - ((x >>> 1) & 0x55555555);