tsc-ts 0.0.9 → 0.1.0

package/src/compiler/transformers/runtime-syntax.ts

@@ -56,6 +56,7 @@ import {
 import type { EmitResolver } from './emit-resolver.js';
 import { ConstantKind, type Evaluation } from './reference-resolver.js';
 import { type TypeScriptFacts } from './subtree-facts.js';
+import { nodeIsDecorated } from './decorator-utilities.js';
 import { Transformer } from './transformer.js';
 import {
   getInnermostModuleDeclaration,
@@ -65,6 +66,7 @@ import {
   isInstantiatedModule,
   isParameterPropertyDeclaration,
   isSameNode,
+  modifierFlagsOf,
 } from './utilities.js';
 
 const typeScriptModifiers =
@@ -577,7 +579,10 @@ export class RuntimeSyntax extends Transformer {
     let name = visitedName instanceof Identifier ? (visitedName as Identifier) : undefined;
     if (
       name === undefined &&
-      (exported || childIsDecorated(this.options.experimentalDecorators === true, node.members))
+      (exported ||
+        childIsDecorated(this.options.experimentalDecorators === true, node.members) ||
+        ((modifierFlagsOf(node) & exportDefault) !== exportDefault &&
+          nodeIsDecorated(this.options.experimentalDecorators === true, node, undefined, undefined)))
     )
       name = this.factory.createGeneratedNameForNode(node, 0, '', '');
     const updated: Node = this.factory.updateClassDeclaration(

package/src/compiler/transformers/syntax-facts.ts

@@ -4,7 +4,6 @@ import {
   BinaryExpression,
   BindingElement,
   BindingPattern,
-  CallExpression,
   CatchClause,
   ForInOrOfStatement,
   FunctionDeclaration,
@@ -29,6 +28,7 @@ import {
 import { ClusteredIntLinkTable } from '../link-tables.js';
 import { isTypeNodeKind } from '../printer/utilities.js';
 import { SyntaxKind } from '../syntax-kind.js';
+import { isImportCall } from '../ast-utilities.js';
 import { TokenFlags } from '../types.js';
 import { getElementsOfBindingOrAssignmentPattern, getTargetOfBindingOrAssignmentElement } from './destructuring.js';
 
@@ -267,12 +267,7 @@ export class SyntaxFacts extends NodeVisitor {
             : SubtreeFacts.None)
         );
       case SyntaxKind.CallExpression:
-        return (
-          this.children(node) |
-          (node instanceof CallExpression && node.expression.kind === SyntaxKind.ImportKeyword
-            ? SubtreeFacts.ContainsDynamicImport
-            : SubtreeFacts.None)
-        );
+        return this.children(node) | (isImportCall(node) ? SubtreeFacts.ContainsDynamicImport : SubtreeFacts.None);
       case SyntaxKind.MetaProperty:
         return node instanceof MetaProperty ? this.propagate(node.name) & ~SubtreeFacts.ContainsIdentifier : 0;
       case SyntaxKind.SpreadElement:

package/src/compiler/transformers/type-eraser.ts

@@ -398,7 +398,16 @@ export class TypeEraser extends Transformer {
       case SyntaxKind.ImportClause:
         if (node instanceof ImportClause) {
           if (node.phaseModifier === SyntaxKind.TypeKeyword) return undefined;
-          const bindings = this.visitNode(node.namedBindings);
+          let bindings = this.visitNode(node.namedBindings);
+          // With a default import, `{}` left by erasing type-only specifiers goes; a `{}` written in the source stays.
+          if (
+            node.name !== undefined &&
+            bindings instanceof NamedImports &&
+            bindings.elements.nodes.length === 0 &&
+            node.namedBindings instanceof NamedImports &&
+            node.namedBindings.elements.nodes.length !== 0
+          )
+            bindings = undefined;
           if (node.name === undefined && bindings === undefined) return undefined;
           return factory.updateImportClause(node, node.phaseModifier, node.name, bindings);
         }

package/src/compiler/transformers/type-serialization.ts

@@ -22,6 +22,7 @@ import {
   UnionTypeNode,
   VariableDeclaration,
   getIsTypeOnly,
+  getText,
 } from '../ast.js';
 import { getStrictOptionValue } from '../options.js';
 import { SyntaxKind } from '../syntax-kind.js';
@@ -119,10 +120,10 @@ function resolveEntityName(
     const namespace = resolveEntityName(resolver, name.left, SymbolFlags.Namespace, false, location);
     if (namespace === undefined) return undefined;
     if (namespace === unknownSymbol) return namespace;
-    let member = resolver.getExportOfSymbol(namespace, name.right.text);
+    let member = resolver.getExportOfSymbol(namespace, getText(name.right));
     if (member === undefined && (namespace.flags & SymbolFlags.Alias) !== 0) {
       const target = resolver.resolveAlias(namespace);
-      if (target !== undefined) member = resolver.getExportOfSymbol(target, name.right.text);
+      if (target !== undefined) member = resolver.getExportOfSymbol(target, getText(name.right));
     }
     if (member === undefined || (member.flags & (meaning | SymbolFlags.Alias)) === 0) return undefined;
     symbol = member;

package/src/compiler/transformers/visitor-base.ts

@@ -1186,6 +1186,7 @@ export abstract class VisitorBase extends VisitorHooks {
             this.visitModifiers(node.modifiers),
             node.keyword,
             required(this.visitNode(node.name), node.name),
+            this.visitNode(node.attributes) as TypeLiteralNode | undefined,
             this.visitNode(node.body),
           );
         break;
@@ -1340,7 +1341,7 @@ export abstract class VisitorBase extends VisitorHooks {
           return this.factory.updateQualifiedName(
             node,
             required(this.visitNode(node.left), node.left),
-            asIdentifier(this.visitNode(node.right), node.right),
+            required(this.visitNode(node.right), node.right),
           );
         break;
       case SyntaxKind.RestType:

package/src/compiler/transformers/visitor-hooks.ts

@@ -144,11 +144,16 @@ export abstract class VisitorHooks {
     if (declarations.length === 0) return updated;
     const factory = this.factory;
     if (updated === undefined) return factory.createBlock(declarations, true);
-    if (!(updated instanceof Block))
-      return factory.createBlock(
-        this.context.mergeEnvironment([factory.createReturnStatement(updated)], declarations),
-        false,
+    if (!(updated instanceof Block)) {
+      // The return statement takes the expression's range, so its comments are emitted once, before `return`.
+      this.context.addEmitFlags(updated, EmitFlags.NoComments);
+      const block = this.context.convertToFunctionBlock(updated, false);
+      return factory.updateBlock(
+        block,
+        this.context.mergeEnvironmentList(block.statements, declarations),
+        block.multiLine,
       );
+    }
     return factory.updateBlock(
       updated,
       this.context.mergeEnvironmentList(updated.statements, declarations),

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';
 
@@ -772,6 +777,9 @@ export class Orchestrator {
     times.parseTime = performance.now() - parseStart;
     const bindStart = performance.now();
     const checked = new CheckedProgram(program);
+    // The project's incremental program, made after checking, keeps the globals found checking a file
+    // with the file.
+    checked.globalsInFileDiagnostics = true;
     times.bindTime = performance.now() - bindStart;
     const options = program.options;
     const count = mayUseThreads ? checkerThreads(options.checkers, options.singleThreaded, program) : 1;
@@ -792,10 +800,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 +925,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

@@ -64,6 +64,8 @@ export abstract class System extends CommandLineHost {
 
   /** Returns `''` for unset variables. */
   abstract getEnvironmentVariable(name: string): string;
+  /** Whether the variable is set, perhaps to `''`. */
+  abstract hasEnvironmentVariable(name: string): boolean;
   abstract write(text: string): void;
   abstract fileExists(path: string): boolean;
   abstract directoryExists(path: string): boolean;
@@ -199,6 +201,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

@@ -8,12 +8,15 @@ import {
   CheckedProgram,
   CompilerProgram,
   CompileTimes,
+  declarationDiagnosticsDue,
   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 +24,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 +139,215 @@ 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;
+    if (declarationDiagnosticsDue(compilerProgram, diagnostics, false))
+      for (const d of compilerProgram.getDeclarationDiagnostics()) diagnostics.push(d);
+    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();
+  });
+  // `report` adds the declaration errors once the thread has found them, when they are due.
+  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,8 +363,12 @@ 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);
+  // The incremental program made after checking keeps the globals found checking a file with the file.
+  if (work.incremental) checked.globalsInFileDiagnostics = true;
   times.bindTime = performance.now() - bindStart;
   mark('checker created');
   if (work.incremental && !checksIncrementalOnThreads(sys, program.commandLine.buildInfoFileName())) {
@@ -176,6 +406,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,12 +552,25 @@ 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) {
     const emitStart = performance.now();
     emitResult = program.emit(writer);
-    program.times.emitTime = performance.now() - emitStart;
+    program.times.emitTime += performance.now() - emitStart;
   }
   for (const diagnostic of emitResult.diagnostics) diagnostics.push(diagnostic);
   const all = sortAndDeduplicateDiagnostics(diagnostics);