tsc-ts 0.0.8 → 0.0.10

package/dist/api/compiler/program.js

@@ -7,7 +7,7 @@
  * ```
  */
 import { ArrayLiteralExpression, Decorator, getText, NodeVisitor, ObjectLiteralExpression, ParameterDeclaration, } from './ast.js';
-import { compareDiagnostics, createCompilerDiagnostic, Diagnostic, equalDiagnostics, equalDiagnosticsNoRelatedInfo, useThreadTextCaches, } from './diagnostics.js';
+import { compareDiagnostics, createCompilerDiagnostic, Diagnostic, equalDiagnostics, equalDiagnosticsNoRelatedInfo, sortDiagnostics, useThreadTextCaches, } from './diagnostics.js';
 import { canReplaceFile, FileLoader, jsxRuntimeImportOf, modeAwareKey, needsImportHelpersImportSpecifier, withReplacedFile, } from './file-loader.js';
 import { PackageJsonLookup } from './package-json.js';
 import { ProcessingDiagnostic } from './file-include.js';
@@ -325,34 +325,9 @@ export class Program {
     getResolvedModule(file, moduleName, mode) {
         return this.processed.resolvedModules.get(file.path)?.get(modeAwareKey(moduleName, mode));
     }
-    /** The program files that the imports and type reference directives of `file` resolved to. */
-    /**
-     * The files `file` imports and references through type directives. `byFileName`, the program's
-     * files by file name, finds a file without computing its path when it is resolved by that name.
-     */
-    getResolvedFilesOf(file, byFileName) {
-        const result = [];
-        const modules = this.processed.resolvedModules.get(file.path);
-        if (modules !== undefined)
-            for (const resolved of modules.values()) {
-                const name = resolved.resolvedFileName;
-                if (name === '')
-                    continue;
-                const target = byFileName?.get(name) ?? this.getSourceFileForResolvedModule(name);
-                if (target !== undefined)
-                    result.push(target);
-            }
-        const types = this.processed.typeResolutionsInFile.get(file.path);
-        if (types !== undefined)
-            for (const resolved of types.values()) {
-                const name = resolved.resolvedFileName;
-                if (name === '')
-                    continue;
-                const target = byFileName?.get(name) ?? this.getSourceFile(name);
-                if (target !== undefined)
-                    result.push(target);
-            }
-        return result;
+    /** The files each file added to the program (`ProcessedFiles.addedFiles`), as indices of `getSourceFiles`. */
+    addedFiles() {
+        return this.processed.addedFiles;
     }
     /** The specifier of the implicit JSX runtime import of `file`, if any. */
     jsxRuntimeImportSpecifier(path) {
@@ -986,7 +961,7 @@ class NodeCollector extends NodeVisitor {
 }
 /** Sorts diagnostics and merges duplicates, combining their related information. */
 export function sortAndDeduplicateDiagnostics(diagnostics) {
-    const sorted = [...diagnostics].sort(compareDiagnostics);
+    const sorted = sortDiagnostics(diagnostics);
     if (sorted.length < 2)
         return sorted;
     const result = [];

package/dist/api/compiler/relations.js

@@ -232,6 +232,16 @@ export function isTypeRelatedTo(c, source, target, relation) {
         if ((source.flags & 394239 /* TypeFlags.Singleton */) !== 0)
             return true;
     }
+    else {
+        // What the relater decides first for types that may simplify (Relater.isRelatedToEx): their normal forms are
+        // one type, or can be identical only with identical flags.
+        const s = getNormalizedType(c, source, false);
+        const t = getNormalizedType(c, target, true);
+        if (s === t)
+            return true;
+        if (s.flags !== t.flags)
+            return false;
+    }
     if ((source.flags & 1048576 /* TypeFlags.Object */) !== 0 && (target.flags & 1048576 /* TypeFlags.Object */) !== 0) {
         const related = relation.get(getRelationKey(c, source, target, 0 /* IntersectionState.None */, relation === c.identityRelation, false).key);
         if (related !== 0 /* RelationComparisonResult.None */)

package/dist/api/compiler/symbol.d.ts

@@ -139,7 +139,7 @@ export declare class SymbolRareFields implements ProgramLifetime {
 }
 export declare class Symbol implements ProgramLifetime {
     flags: SymbolFlags;
-    /** The check flags, and `valueDeclarationIsFirst`. */
+    /** The check flags, and `SymbolBits.ValueDeclarationIsFirst`. */
     private bits;
     readonly name: string;
     /**

package/dist/api/compiler/symbol.js

@@ -8,11 +8,9 @@ export class SymbolRareFields {
     /** The value declaration where it is not the first declaration (`Symbol.valueDeclaration`). */
     valueDeclaration = undefined;
 }
-/** In `Symbol.bits`, above the check flags: the value declaration is the first declaration. */
-const valueDeclarationIsFirst = 1 << 30;
 export class Symbol {
     flags;
-    /** The check flags, and `valueDeclarationIsFirst`. */
+    /** The check flags, and `SymbolBits.ValueDeclarationIsFirst`. */
     bits;
     name;
     /**
@@ -35,17 +33,17 @@ export class Symbol {
         this.id = idsAtCreation ? takeSymbolId() : 0;
     }
     get checkFlags() {
-        return (this.bits & ~valueDeclarationIsFirst);
+        return (this.bits & ~1073741824 /* SymbolBits.ValueDeclarationIsFirst */);
     }
     set checkFlags(flags) {
-        this.bits = (this.bits & valueDeclarationIsFirst) | flags;
+        this.bits = (this.bits & 1073741824 /* SymbolBits.ValueDeclarationIsFirst */) | flags;
     }
     /** Makes `node` the first declaration, keeping the value declaration. */
     setFirst(node) {
-        if ((this.bits & valueDeclarationIsFirst) !== 0 && node !== this.declaration) {
+        if ((this.bits & 1073741824 /* SymbolBits.ValueDeclarationIsFirst */) !== 0 && node !== this.declaration) {
             // The value declaration stays what it was.
             this.rareFieldsOrNew().valueDeclaration = this.declaration;
-            this.bits &= ~valueDeclarationIsFirst;
+            this.bits &= ~1073741824 /* SymbolBits.ValueDeclarationIsFirst */;
         }
         this.declaration = node;
     }
@@ -54,7 +52,7 @@ export class Symbol {
      * says; any other is kept in the rare fields.
      */
     get valueDeclaration() {
-        if ((this.bits & valueDeclarationIsFirst) !== 0)
+        if ((this.bits & 1073741824 /* SymbolBits.ValueDeclarationIsFirst */) !== 0)
             return this.declaration;
         const group = this.rareFields;
         return group === undefined ? undefined : group.valueDeclaration;
@@ -62,12 +60,12 @@ export class Symbol {
     set valueDeclaration(node) {
         const group = this.rareFields;
         if (node !== undefined && node === this.declaration) {
-            this.bits |= valueDeclarationIsFirst;
+            this.bits |= 1073741824 /* SymbolBits.ValueDeclarationIsFirst */;
             if (group !== undefined)
                 group.valueDeclaration = undefined;
             return;
         }
-        this.bits &= ~valueDeclarationIsFirst;
+        this.bits &= ~1073741824 /* SymbolBits.ValueDeclarationIsFirst */;
         if (node !== undefined || group !== undefined)
             this.rareFieldsOrNew().valueDeclaration = node;
     }

package/dist/api/library/diagnostics.d.ts

@@ -11,3 +11,13 @@ export declare function diagnosticOf(d: CompilerDiagnostic): Diagnostic;
  * them. Declaration diagnostics are empty, as tsgo's API returns them.
  */
 export declare function programDiagnostics(checked: CheckedProgram, kind: DiagnosticKind, file: SourceFile | undefined): readonly CompilerDiagnostic[];
+/**
+ * What `semantic` answers for each of `files` and what `global` answers, after checking `files` and
+ * no other file. Checking one file can add diagnostics located in another, so every file is checked
+ * before any file's diagnostics are collected. With every file of the program listed, the answers are
+ * those of the full check.
+ */
+export declare function checkedFileDiagnostics(checked: CheckedProgram, files: readonly SourceFile[]): {
+    files: (readonly CompilerDiagnostic[])[];
+    global: readonly CompilerDiagnostic[];
+};

package/dist/api/library/diagnostics.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tsc-ts",
-  "version": "0.0.8",
+  "version": "0.0.10",
   "description": "The TypeScript 7 compiler, ported to TypeScript and compiled to a native executable.",
   "license": "Apache-2.0",
   "repository": {
@@ -29,18 +29,18 @@
     "./package.json": "./package.json"
   },
   "dependencies": {
-    "@scriptc/threads": "0.4.2"
+    "@scriptc/threads": "0.4.5"
   },
   "engines": {
     "node": ">=20"
   },
   "optionalDependencies": {
-    "@tsc-ts/darwin-arm64": "0.0.8",
-    "@tsc-ts/darwin-x64": "0.0.8",
-    "@tsc-ts/linux-arm64-gnu": "0.0.8",
-    "@tsc-ts/linux-arm64-musl": "0.0.8",
-    "@tsc-ts/linux-x64-gnu": "0.0.8",
-    "@tsc-ts/linux-x64-musl": "0.0.8",
-    "@tsc-ts/win32-x64-msvc": "0.0.8"
+    "@tsc-ts/darwin-arm64": "0.0.10",
+    "@tsc-ts/darwin-x64": "0.0.10",
+    "@tsc-ts/linux-arm64-gnu": "0.0.10",
+    "@tsc-ts/linux-arm64-musl": "0.0.10",
+    "@tsc-ts/linux-x64-gnu": "0.0.10",
+    "@tsc-ts/linux-x64-musl": "0.0.10",
+    "@tsc-ts/win32-x64-msvc": "0.0.10"
   }
 }

package/src/compiler/ast.ts

@@ -8258,6 +8258,8 @@ export class SourceFile extends Node {
   identifierCount: number;
   nodeCount: number;
   textCount: number;
+  /** The API's binary encoding of this file, when an API server keeps it (`keptEncodingOf`). */
+  apiEncoding: Uint8Array | undefined;
   /** Module specifiers of imports, exports, `require` calls and `import()` types, in source order. */
   imports: Node[];
   /** Names of `declare module "x"` augmentations and `declare global` blocks in modules. */
@@ -8325,6 +8327,7 @@ export class SourceFile extends Node {
     this.identifierCount = 0;
     this.nodeCount = 0;
     this.textCount = 0;
+    this.apiEncoding = undefined;
     this.imports = [];
     this.moduleAugmentations = emptyNodes;
     this.ambientModuleNames = emptyStrings;

package/src/compiler/checker-calls.ts

@@ -975,7 +975,9 @@ export function reorderCandidates(c: Checker, signatures: Signature[], callChain
       cutoffIndex++;
     } else spliceIndex = index;
     if (callChainFlags !== 0) signature = getOptionalCallSignature(c, signature, callChainFlags);
-    result.splice(spliceIndex, 0, signature);
+    // Most signatures go at the end, where a push is cheaper than an inserting splice.
+    if (spliceIndex === result.length) result.push(signature);
+    else result.splice(spliceIndex, 0, signature);
   }
   return result;
 }

package/src/compiler/checker-grammar.ts

@@ -3143,7 +3143,8 @@ function checkGrammarObjectLiteralExpression(
   node: ObjectLiteralExpression,
   inDestructuring: boolean,
 ): boolean {
-  const seen = new Map<string, DeclarationMeaning>();
+  // An object literal with one property can't repeat a name, so it needs no table of names.
+  const seen = node.properties.nodes.length > 1 ? new Map<string, DeclarationMeaning>() : undefined;
   for (const property of node.properties.nodes) {
     if (property.kind === SyntaxKind.SpreadAssignment) {
       if (inDestructuring) {
@@ -3222,7 +3223,7 @@ function checkGrammarObjectLiteralExpression(
     }
     if (inDestructuring) continue;
     const effectiveName = getEffectivePropertyNameForPropertyNameNode(g.c, name);
-    if (effectiveName === undefined) continue;
+    if (effectiveName === undefined || seen === undefined) continue;
     const existingKind = seen.get(effectiveName);
     if (existingKind === undefined) {
       seen.set(effectiveName, currentKind);

package/src/compiler/checker-inference.ts

@@ -733,8 +733,13 @@ class InferenceState {
             // Keep candidates with the highest depth first.
             index = 0;
             while (index < inference.candidateDepths.length && inference.candidateDepths[index] >= this.depth) index++;
-            inference.candidates.splice(index, 0, candidate);
-            inference.candidateDepths.splice(index, 0, this.depth);
+            if (index === inference.candidates.length) {
+              inference.candidates.push(candidate);
+              inference.candidateDepths.push(this.depth);
+            } else {
+              inference.candidates.splice(index, 0, candidate);
+              inference.candidateDepths.splice(index, 0, this.depth);
+            }
             clearCachedInferences(this.inferences);
           }
         }

package/src/compiler/checker-members.ts

@@ -923,8 +923,12 @@ export function resolveDeclaredMembers(c: Checker, t: InterfaceType): InterfaceT
     const members = getMembersOfSymbol(c, t.symbol!);
     declared.declaredMembersResolved = true;
     declared.declaredMembers = members;
-    declared.declaredCallSignatures = getSignaturesOfSymbol(c, members.get(InternalSymbolName.Call));
-    declared.declaredConstructSignatures = getSignaturesOfSymbol(c, members.get(InternalSymbolName.New));
+    // Most interfaces declare neither, and share one empty list.
+    const call = members.get(InternalSymbolName.Call);
+    const construct = members.get(InternalSymbolName.New);
+    declared.declaredCallSignatures = call !== undefined ? getSignaturesOfSymbol(c, call) : emptySignatures;
+    declared.declaredConstructSignatures =
+      construct !== undefined ? getSignaturesOfSymbol(c, construct) : emptySignatures;
     declared.declaredIndexInfos = getIndexInfosOfSymbol(c, t.symbol!);
   }
   return declared;
@@ -1570,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-source-file.ts

@@ -161,6 +161,40 @@ function checkSourceFileWorker(c: Checker, file: SourceFile): void {
   links.deferredNodes = undefined;
 }
 
+/**
+ * Checks the statements `start` to `end` of the declaration file `file`, one of the ranges that several
+ * checkers check it in (parallel-check.ts), and returns whether the checker then has diagnostics in the
+ * file. The range ending the file also runs the checks of the whole file. The file is not marked checked.
+ *
+ * When no range finds a diagnostic in the file, checking it whole would find none either: each statement
+ * is checked by the checker of its range. Otherwise the file is checked whole (`startParallelCheck`): the
+ * diagnostics of the ranges can differ from the file's, where they depend on the order the file's
+ * declarations are resolved in. A union type prints its members in the order the checker created them,
+ * and a check that a symbol's first declaration runs reports on all its declarations.
+ */
+export function checkSourceFileRange(c: Checker, file: SourceFile, start: number, end: number): boolean {
+  const statements = getStatements(file)!.nodes;
+  c.fileBeingChecked = file;
+  c.saveDeferredDiagnostics = true;
+  for (let i = start; i < end; i++) checkSourceElement(c, statements[i]!);
+  checkDeferredNodes(c, file);
+  const whole = end === statements.length;
+  if (whole && isExternalOrCommonJSModule(file)) checkExternalModuleExports(c, file);
+  c.renamedBindingElementsInTypes.length = 0;
+  if (whole) {
+    checkGrammarSourceFile(c, file);
+    checkDeferredNodes(c, file);
+    checkPendingExternalEmitHelpers(c, file);
+  }
+  c.fileBeingChecked = undefined;
+  c.saveDeferredDiagnostics = false;
+  produceDeferredIterationErrors(c);
+  produceDeferredCollisionChecks(c);
+  // Deferred nodes of a later range are queued again (checkNodeDeferred).
+  c.nodeLinks(file).deferredNodes = undefined;
+  return c.diagnostics.forFile(file.fileName).length > 0;
+}
+
 /** Checks a statement, declaration, class member or type node. */
 export function checkSourceElement(c: Checker, node: Node | undefined): void {
   if (node === undefined) return;

package/src/compiler/checker-symbols.ts

@@ -957,6 +957,7 @@ export function setGlobal(c: Checker, name: string, symbol: Symbol): void {
 function setMergedSymbol(c: Checker, id: number, target: Symbol): void {
   if (c.mergedSymbolChanges !== undefined) c.mergedSymbolChanges.set(c.mergedSymbols, id, target);
   else c.mergedSymbols.set(id, target);
+  c.mergedSymbolIds.add(id);
 }
 
 /** Merges script locals into globals; ambient modules and augmentations wait for global types. */
@@ -1298,7 +1299,7 @@ function recordMergedSymbol(c: Checker, target: Symbol, source: Symbol): void {
 
 export function getMergedSymbol(c: Checker, symbol: Symbol): Symbol {
   const id = symbol.id;
-  if (id !== 0) {
+  if (id !== 0 && c.mergedSymbolIds.has(id)) {
     const merged = c.mergedSymbols.get(id);
     if (merged !== undefined) return merged;
   }

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

@@ -33,7 +33,7 @@ import type { DeferredCollisionCheck } from './checker-generated-code.js';
 import type { EmitHelperFileLinks } from './checker-emit-helpers.js';
 import { sideOf } from './side-state.js';
 import type { Node, PatternAmbientModule, SourceFile } from './ast.js';
-import { CompactSymbolLinkTable, IntLinkTable, LinkTable, SparseLinkTable } from './link-tables.js';
+import { CompactSymbolLinkTable, IntLinkTable, LinkTable, PagedIdSet, SparseLinkTable } from './link-tables.js';
 import { getErrorRangeForNode, getSourceFileOfNode } from './binder-utilities.js';
 import { Diagnostic, type DiagnosticMessage, Diagnostics, compareDiagnostics } from './diagnostics.js';
 import {
@@ -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 = [];
@@ -402,6 +426,11 @@ export class Checker implements TypeChecking {
   readonly resolvedSignatures = new SparseLinkTable<Signature>();
   /** Merged symbols, indexed by the id of the symbol merged into them. */
   readonly mergedSymbols: Map<number, Symbol>;
+  /**
+   * The ids that `mergedSymbols` has, or had: most symbols are merged into none, and `getMergedSymbol`
+   * finds that here without probing the map.
+   */
+  readonly mergedSymbolIds = new PagedIdSet();
   /** Globals merged from the default libraries, shared with other checkers. */
   libGlobals: LibGlobals | undefined;
   /** The program's globals and module augmentations as another checker merged them, shared with it. */
@@ -746,6 +775,7 @@ export class Checker implements TypeChecking {
       this.globals = libs.copyGlobals();
       this.mergedSymbols = libs.copyMergedSymbols();
     }
+    for (const id of this.mergedSymbols.keys()) this.mergedSymbolIds.add(id);
     this.globalThisSymbol = this.newSymbol(SymbolFlags.Module, 'globalThis');
     this.globalThisSymbol.checkFlags = CheckFlags.Readonly;
     this.globalThisSymbol.exports = this.globals;
@@ -934,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. */
@@ -1087,6 +1130,7 @@ export function disposeChecker(c: Checker): void {
     c.mergedSymbols.clear();
     c.globals.clear();
   }
+  c.mergedSymbolIds.clear();
   c.sharedSymbolCopies.clear();
   c.memberPositionsInLists.clear();
   c.memberNamesOfLists.clear();

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