tsc-ts 0.0.9 → 0.0.10

package/src/compiler/checker-members.ts

@@ -1574,7 +1574,9 @@ export function getPropertyOfTypeEx(
 ): Symbol | undefined {
   if (!isOwnReducedApparentType(t)) t = getReducedApparentTypeWorker(c, t);
   if ((t.flags & TypeFlags.Object) !== 0) {
-    const resolved = resolveStructuredTypeMembers(c, t);
+    // The first test of resolveStructuredTypeMembers, here where most lookups find the members resolved.
+    const resolved =
+      (t.objectFlags & ObjectFlags.MembersResolved) !== 0 ? (t as StructuredType) : resolveStructuredTypeMembers(c, t);
     const symbol = getResolvedMember(resolved, name);
     if (symbol !== undefined && includeTypeOnlyMembers) return symbol;
     if (symbol !== undefined) {

package/src/compiler/checker-type-factory.ts

@@ -998,7 +998,8 @@ export function unionContainsSortedTypes(c: Checker, union: UnionType, types: re
 export function insertType(c: Checker, types: Type[], t: Type): boolean {
   const index = binarySearchTypes(c, types, t);
   if (index >= 0) return false;
-  types.splice(~index, 0, t);
+  if (~index === types.length) types.push(t);
+  else types.splice(~index, 0, t);
   return true;
 }
 
@@ -1214,7 +1215,8 @@ function insertTypeNearLast(c: Checker, set: TypeSet, t: Type): void {
     if (r < 0) low = middle + 1;
     else high = middle - 1;
   }
-  types.splice(low, 0, t);
+  if (low === types.length) types.push(t);
+  else types.splice(low, 0, t);
   set.last = low;
 }
 

package/src/compiler/checker.ts

@@ -245,6 +245,30 @@ class DiagnosticCollection {
     return this.global.slice();
   }
 
+  /** The global diagnostics `withoutNewGlobals` removed. */
+  removedGlobals = 0;
+
+  /** Runs `run`, then removes the global diagnostics it added. */
+  withoutNewGlobals<T>(run: () => T): T {
+    const outer = this.log;
+    const added: Diagnostic[] = [];
+    this.log = added;
+    try {
+      return run();
+    } finally {
+      this.log = outer;
+      if (outer !== undefined) for (const d of added) outer.push(d);
+      const globals = new Set<Diagnostic>();
+      for (const d of added) if (d.file === undefined) globals.add(d);
+      if (globals.size > 0) {
+        this.removedGlobals += globals.size;
+        let kept = 0;
+        for (const d of this.global) if (!globals.has(d)) this.global[kept++] = d;
+        this.global.length = kept;
+      }
+    }
+  }
+
   /** Records the diagnostics added from now on. */
   startLog(): void {
     this.log = [];
@@ -940,6 +964,19 @@ export class Checker implements TypeChecking {
     return this.diagnostics.globals();
   }
 
+  /**
+   * Runs `run` (such as emitting declarations), then forgets the global diagnostics it reported:
+   * the program collects global diagnostics before it emits.
+   */
+  withoutGlobalDiagnostics<T>(run: () => T): T {
+    return this.diagnostics.withoutNewGlobals(run);
+  }
+
+  /** The global diagnostics `withoutGlobalDiagnostics` forgot so far. */
+  forgottenGlobalDiagnostics(): number {
+    return this.diagnostics.removedGlobals;
+  }
+
   // ---- Links
 
   /** The rarely used links of `symbol`, created on first use. */

package/src/compiler/compile-program.ts

@@ -13,7 +13,11 @@ import { CheckerDeclarationEmitResolver, CheckerEmitResolver } from './checker-e
 import { getEmitModuleFormatOfFile } from './program-utilities.js';
 import { DeclarationGlobals, SyntacticDeclarationEmitResolver } from './transformers/declarations-syntactic.js';
 import { mark } from './timeline.js';
-import type { EmitResolver } from './transformers/emit-resolver.js';
+import { DecoratorMetadata } from './transformers/decorator-metadata.js';
+import { SyntaxFacts } from './transformers/syntax-facts.js';
+import type { TypeReferenceSerializationKind } from './transformers/type-serialization.js';
+import { EmitContext } from './printer/emit-context.js';
+import { type EmitResolver, SyntacticEmitResolver } from './transformers/emit-resolver.js';
 import { ModuleFormatHost } from './transformers/module.js';
 import { type MergedGlobals, ModuleLookup, ReferenceResolver } from './transformers/reference-resolver.js';
 
@@ -193,6 +197,100 @@ export class EmitIndexes {
   }
 }
 
+/**
+ * The JavaScript emit of a program's files without a checker, for emit threads (parallel-emit.ts).
+ * JavaScript emit asks the checker only how decorator metadata serializes a type
+ * (`CheckerEmitResolver`): with `kinds`, the answers the main thread's checker gave
+ * (`recordMetadataKinds`), else files with decorator metadata are emitted by a `ProgramEmitter`.
+ */
+export class JavaScriptEmitter {
+  private readonly host: ProgramEmitHost;
+  private readonly recorded: RecordedKindsEmitResolver | undefined;
+
+  constructor(program: Program, kinds: readonly number[] = []) {
+    const options = program.options;
+    const indexes = program.emitIndexes;
+    const references = new ReferenceResolver(
+      options,
+      program.getSourceFiles(),
+      new ProgramModules(program),
+      indexes !== undefined ? indexes.globals : undefined,
+    );
+    this.recorded = kinds.length > 0 ? new RecordedKindsEmitResolver(options, references, kinds) : undefined;
+    this.host = new ProgramEmitHost(program, this.recorded ?? new SyntacticEmitResolver(options, references));
+  }
+
+  /**
+   * Emits `file`, or returns undefined if its decorator metadata asked for a kind that wasn't recorded: what
+   * was written is then not the file's emit, and it must be emitted with the checker.
+   */
+  emit(file: SourceFile, writer: OutputWriter): EmitResult | undefined {
+    const host = this.host;
+    const recorded = this.recorded;
+    if (recorded !== undefined) recorded.missed = false;
+    host.writer = writer;
+    const result = emitFiles(host, [file], EmitOnly.Js);
+    host.writer = undefined;
+    return recorded !== undefined && recorded.missed ? undefined : result;
+  }
+}
+
+/**
+ * The serialization kinds of decorator metadata that the checker of `checked` gives the type references of
+ * `files`, in the order JavaScript emit asks for them: the type name's node id, the location's node id (-1 for
+ * none) and the kind, for each. Only the decorator metadata transform runs, as the first transform of emit.
+ */
+export function recordMetadataKinds(checked: CheckedProgram, files: readonly SourceFile[]): number[] {
+  const program = checked.program;
+  const options = program.options;
+  const indexes = program.emitIndexes;
+  const references = new ReferenceResolver(
+    options,
+    program.getSourceFiles(),
+    new ProgramModules(program),
+    indexes !== undefined ? indexes.globals : undefined,
+  );
+  const resolver = new RecordingEmitResolver(options, references, checked.checker);
+  for (const file of files)
+    new DecoratorMetadata(new EmitContext(), options, resolver, new SyntaxFacts()).transformSourceFile(file);
+  return resolver.kinds;
+}
+
+/** A `CheckerEmitResolver` that records the serialization kinds it gives (`recordMetadataKinds`). */
+class RecordingEmitResolver extends CheckerEmitResolver {
+  readonly kinds: number[] = [];
+
+  getTypeReferenceSerializationKind(typeName: Node, location: Node | undefined): TypeReferenceSerializationKind {
+    const kind = super.getTypeReferenceSerializationKind(typeName, location);
+    this.kinds.push(typeName.id, location === undefined ? -1 : location.id, kind);
+    return kind;
+  }
+}
+
+/** Answers serialization kinds from those recorded on the main thread; `missed` once one wasn't. */
+class RecordedKindsEmitResolver extends SyntacticEmitResolver {
+  /** The kind and location of each type name, by the type name's node id. */
+  private readonly byName = new Map<number, number>();
+  missed = false;
+
+  constructor(
+    options: CompilerOptions,
+    referenceResolver: ReferenceResolver,
+    private readonly kinds: readonly number[],
+  ) {
+    super(options, referenceResolver);
+    for (let i = 0; i < kinds.length; i += 3) if (!this.byName.has(kinds[i]!)) this.byName.set(kinds[i]!, i);
+  }
+
+  getTypeReferenceSerializationKind(typeName: Node, location: Node | undefined): TypeReferenceSerializationKind {
+    const at = this.byName.get(typeName.id);
+    if (at !== undefined && this.kinds[at + 1] === (location === undefined ? -1 : location.id))
+      return this.kinds[at + 2]! as TypeReferenceSerializationKind;
+    this.missed = true;
+    return super.getTypeReferenceSerializationKind(typeName, location);
+  }
+}
+
 /** A checked program and the emit of its files. */
 export class ProgramEmitter {
   private host: ProgramEmitHost | undefined = undefined;
@@ -354,16 +452,25 @@ export class PlainProgram extends CompilerProgram {
     const program = this.program;
     const files = program.getSourceFiles();
     const parallel = this.checked.emittedInParallel;
-    // Checker threads emitted the files they checked (parallel-check.ts); the others are emitted here, in order.
+    // Checker threads emitted the files they checked (parallel-check.ts), or emit threads their JavaScript
+    // (parallel-emit.ts); the rest is emitted here, in order.
     const result =
       parallel === undefined
         ? this.emitter.emit(files, EmitOnly.All, writer)
         : combineEmitResults(
             files.map((file, i) => {
               const emitted = parallel[i];
-              return emitted !== undefined
-                ? writeHeldOutputs(emitted, writer)
-                : this.emitter.emit([file], EmitOnly.All, writer);
+              // The declaration thread emitted the declarations of the files it could (parallel-emit.ts).
+              const ahead = this.checked.declarationsEmittedAhead;
+              const declarations = (): EmitResult => ahead?.[i] ?? this.emitter.emit([file], EmitOnly.Dts, writer);
+              if (emitted === undefined)
+                return ahead !== undefined
+                  ? combineEmitResults([this.emitter.emit([file], EmitOnly.Js, writer), declarations()])
+                  : this.emitter.emit([file], EmitOnly.All, writer);
+              const written = writeHeldOutputs(emitted, writer);
+              // Emit threads emit JavaScript only.
+              if (!this.checked.javaScriptEmittedOnThreads || !getEmitDeclarations(options)) return written;
+              return combineEmitResults([written, declarations()]);
             }),
           );
     if (options.noEmit === true) {
@@ -390,9 +497,15 @@ export function handleNoEmitOnError(program: CompilerProgram): EmitResult | unde
 
 /**
  * Config and syntax errors; without syntax errors, program, global and semantic errors too, and
- * declaration errors under `noEmit` (or `withDeclarationDiagnostics`).
+ * declaration errors under `noEmit` (or `withDeclarationDiagnostics`). With `declarationsLater`, the
+ * declaration errors are left to `program.emit`, which reports them under `noEmit` (without
+ * `noEmitOnError`) whether or not other errors were found.
  */
-export function getDiagnosticsOfProgram(program: CompilerProgram, withDeclarationDiagnostics: boolean): Diagnostic[] {
+export function getDiagnosticsOfProgram(
+  program: CompilerProgram,
+  withDeclarationDiagnostics: boolean,
+  declarationsLater: boolean = false,
+): Diagnostic[] {
   const result: Diagnostic[] = [...program.getConfigFileParsingDiagnostics()];
   const configCount = result.length;
   for (const d of program.getSyntacticDiagnostics()) result.push(d);
@@ -414,6 +527,7 @@ export function getDiagnosticsOfProgram(program: CompilerProgram, withDeclaratio
     mark('semantic diagnostics');
   }
   if (
+    !declarationsLater &&
     (withDeclarationDiagnostics || options.noEmit === true) &&
     getEmitDeclarations(options) &&
     result.length === configCount

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

@@ -256,6 +256,8 @@ class ParseTask {
   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,
@@ -266,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,
@@ -296,12 +301,20 @@ class ParseTask {
   }
 }
 
+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);
@@ -419,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[])[],
   ) {}
 }
 
@@ -446,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,
   );
 }
 
@@ -1393,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);
@@ -1457,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 !== undefined && 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) {
@@ -1485,10 +1518,13 @@ export class FileLoader {
         }
         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);
@@ -1500,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) {
@@ -1536,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);
         }