tsc-ts 0.1.0 → 0.1.2

package/src/compiler/checker-heritage.ts

@@ -965,16 +965,25 @@ const enum MemberKind {
  * (with `checkPrivateNames`) private names shared by static and instance members.
  */
 export function checkObjectTypeForDuplicateDeclarations(c: Checker, node: Node, checkPrivateNames: boolean): void {
-  const instanceNames = new Map<string, MemberKind>();
-  const staticNames = new Map<string, MemberKind>();
-  const privateNames = new Map<string, number>();
+  // Only a symbol with several declarations can be a duplicate, so the maps are created for the first one.
+  let instanceNames: Map<string, MemberKind> | undefined;
+  let staticNames: Map<string, MemberKind> | undefined;
+  let privateNames: Map<string, number> | undefined;
   const nodeInAmbientContext = (node.flags & NodeFlags.Ambient) !== 0;
   for (const member of getMembers(node)!.nodes) {
     if (member.kind === SyntaxKind.Constructor) {
       for (const param of getParameters(member)!.nodes)
         if (isParameterPropertyDeclaration(param, member) && !isBindingPattern(getName(param))) {
           const symbol = getSymbolOfDeclaration(c, param);
-          if (symbol !== undefined) checkPropertyOrAccessor(c, node, instanceNames, symbol, MemberKind.Property, false);
+          if (symbol !== undefined && declarationCount(symbol) > 1)
+            checkPropertyOrAccessor(
+              c,
+              node,
+              (instanceNames ??= new Map<string, MemberKind>()),
+              symbol,
+              MemberKind.Property,
+              false,
+            );
         }
       continue;
     }
@@ -988,21 +997,26 @@ export function checkObjectTypeForDuplicateDeclarations(c: Checker, node: Node,
         symbol.name,
         symbolToString(c, getSymbolOfDeclaration(c, node)!),
       );
-    const names = memberIsStatic ? staticNames : instanceNames;
-    const hasAccessorModifier = hasSyntacticModifier(member, ModifierFlags.Accessor);
-    if (
-      (member.kind === SyntaxKind.PropertyDeclaration && !hasAccessorModifier) ||
-      member.kind === SyntaxKind.PropertySignature
-    )
-      checkPropertyOrAccessor(c, node, names, symbol, MemberKind.Property, memberIsStatic);
-    else if (
-      member.kind === SyntaxKind.GetAccessor ||
-      member.kind === SyntaxKind.SetAccessor ||
-      (member.kind === SyntaxKind.PropertyDeclaration && hasAccessorModifier)
-    )
-      checkPropertyOrAccessor(c, node, names, symbol, MemberKind.Accessor, memberIsStatic);
+    if (declarationCount(symbol) > 1) {
+      const names = memberIsStatic
+        ? (staticNames ??= new Map<string, MemberKind>())
+        : (instanceNames ??= new Map<string, MemberKind>());
+      const hasAccessorModifier = hasSyntacticModifier(member, ModifierFlags.Accessor);
+      if (
+        (member.kind === SyntaxKind.PropertyDeclaration && !hasAccessorModifier) ||
+        member.kind === SyntaxKind.PropertySignature
+      )
+        checkPropertyOrAccessor(c, node, names, symbol, MemberKind.Property, memberIsStatic);
+      else if (
+        member.kind === SyntaxKind.GetAccessor ||
+        member.kind === SyntaxKind.SetAccessor ||
+        (member.kind === SyntaxKind.PropertyDeclaration && hasAccessorModifier)
+      )
+        checkPropertyOrAccessor(c, node, names, symbol, MemberKind.Accessor, memberIsStatic);
+    }
     const name = getName(member);
     if (checkPrivateNames && name !== undefined && name.kind === SyntaxKind.PrivateIdentifier) {
+      privateNames ??= new Map<string, number>();
       let flags = privateNames.get(symbol.name) ?? 0;
       if (flags === 3) continue;
       flags |= isStatic(member) ? 2 : 1;

package/src/compiler/checker-jsx.ts

@@ -171,6 +171,7 @@ import {
   SymbolFlags,
   type SymbolTable,
 } from './symbol.js';
+import { IdentifierName } from './identifier-name.js';
 
 const enum JsxFlags {
   None = 0,
@@ -1067,7 +1068,7 @@ export function createJsxAttributesTypeFromAttributesProperty(
       // checked as an excess property like the attributes.
       const childrenDeclaration = new PropertySignatureDeclaration(
         undefined,
-        new Identifier(jsxChildrenPropertyName),
+        new Identifier(new IdentifierName(jsxChildrenPropertyName)),
         undefined,
         undefined,
         undefined,

package/src/compiler/checker-modules.ts

@@ -2167,14 +2167,16 @@ function getSymbolFlagsEx(
   excludeTypeOnlyMeanings: boolean,
   excludeLocalMeanings: boolean,
 ): SymbolFlags {
-  const seen = new Set<Symbol>();
+  // Only a chain of aliases needs the set, so most calls never create it.
+  let seen: Set<Symbol> | undefined;
   let flags = excludeLocalMeanings ? SymbolFlags.None : symbol.flags;
   while ((symbol.flags & SymbolFlags.Alias) !== 0) {
     if (excludeTypeOnlyMeanings && getTypeOnlyAliasDeclaration(c, symbol) !== undefined) break;
     const target = getExportSymbolOfValueSymbolIfExported(c, resolveAlias(c, symbol));
     if (target === c.unknownSymbol) return SymbolFlags.All;
     if ((target.flags & SymbolFlags.Alias) !== 0) {
-      if (target === symbol || seen.has(target)) break;
+      if (target === symbol || seen?.has(target)) break;
+      seen ??= new Set<Symbol>();
       seen.add(symbol);
       seen.add(target);
     }

package/src/compiler/checker-source-file.ts

@@ -639,7 +639,7 @@ function checkTypeMemberAccessor(c: Checker, node: Node): void {
 /** Variadic tuple elements must be array-like. */
 function checkTupleRestElements(c: Checker, node: TupleTypeNode): void {
   for (const e of node.elements.nodes) {
-    if ((getTupleElementFlags(c, e) & ElementFlags.Variadic) === 0) continue;
+    if ((getTupleElementFlags(e) & ElementFlags.Variadic) === 0) continue;
     if (!isArrayLikeType(c, getTypeFromTypeNode(c, getType(e)!))) {
       c.error(e, Diagnostics.A_rest_element_type_must_be_an_array_type);
       return;

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

@@ -1196,40 +1196,79 @@ export function getUnionTypeEx(
 ): Type {
   if (types.length === 0) return c.neverType;
   if (types.length === 1) return types[0]!;
-  // Optimize the common case of unioning a union with some other type, like `undefined`.
-  if (
-    types.length === 2 &&
-    origin === undefined &&
-    ((types[0]!.flags & TypeFlags.Union) !== 0 || (types[1]!.flags & TypeFlags.Union) !== 0)
-  ) {
-    let id1 = types[0]!.id;
-    let id2 = types[1]!.id;
+  // Unioning two types is the common case, both a union with some other type, like `undefined`, and
+  // two constituents of a list, and the same pairs recur. The union is a function of the two types,
+  // the reduction and the alias, so the result is cached by the pair. A union that exceeded the
+  // complexity limit was reported at the expression that needed it and comes back as the error
+  // type: caching that would silence the report at the next expression with the same input list, so
+  // an error result is not cached.
+  if (types.length === 2 && origin === undefined) {
+    const t0 = types[0]!;
+    const t1 = types[1]!;
+    let id1 = t0.id;
+    let id2 = t1.id;
     if (id1 > id2) {
       const t = id1;
       id1 = id2;
       id2 = t;
     }
-    // Without an alias, both ids and the reduction pack into one exact number.
-    if (alias === undefined && id2 < UnionPairIdLimit) {
+    // Without an alias or a constrained intersection, both ids and the reduction pack into one
+    // exact number. A constrained intersection's reduction resolves a type variable's constraint
+    // (`addTypeToUnion`), so those pairs take the general path.
+    if (
+      alias === undefined &&
+      id2 < UnionPairIdLimit &&
+      !isConstrainedIntersection(t0) &&
+      !isConstrainedIntersection(t1)
+    ) {
       const id = (id1 * UnionPairIdLimit + id2) * 4 + unionReduction;
       let result = c.unionOfUnionTypesById.get(id);
       if (result === undefined) {
         result = getUnionTypeWorker(c, types, unionReduction, alias, undefined);
-        c.unionOfUnionTypesById.set(id, result);
+        if (result !== c.errorType) c.unionOfUnionTypesById.set(id, result);
       }
       return result;
     }
-    const key = id1 + ',' + id2 + ',' + unionReduction + aliasKey(alias);
-    let result = c.unionOfUnionTypes.get(key);
+    if ((t0.flags & TypeFlags.Union) !== 0 || (t1.flags & TypeFlags.Union) !== 0) {
+      const key = id1 + ',' + id2 + ',' + unionReduction + aliasKey(alias);
+      let result = c.unionOfUnionTypes.get(key);
+      if (result === undefined) {
+        result = getUnionTypeWorker(c, types, unionReduction, alias, undefined);
+        if (result !== c.errorType) c.unionOfUnionTypes.set(key, result);
+      }
+      return result;
+    }
+  }
+  // Longer lists recur too, from nested unions and from constituents mapped in the same order.
+  // Normalizing a list costs a sort of its constituents and the reductions, and the union is a
+  // function of the list as given, the reduction and the alias, so the result is cached by the list.
+  if (origin === undefined) {
+    const hash = typeListHash(types, alias, unionReduction);
+    let result = c.unionTypesByInputList.get(hash, types, alias, unionReduction);
     if (result === undefined) {
       result = getUnionTypeWorker(c, types, unionReduction, alias, undefined);
-      c.unionOfUnionTypes.set(key, result);
+      if (result !== c.errorType && !hasConstrainedIntersection(types))
+        c.unionTypesByInputList.set(hash, types.slice(), alias, unionReduction, result);
     }
     return result;
   }
   return getUnionTypeWorker(c, types, unionReduction, alias, origin);
 }
 
+/** An intersection that `addTypeToUnion` reduces by resolving a type variable's constraint. */
+function isConstrainedIntersection(t: Type): boolean {
+  return (t.flags & TypeFlags.Intersection) !== 0 && (t.objectFlags & ObjectFlags.IsConstrainedTypeVariable) !== 0;
+}
+
+/** Whether `addTypesToUnion` would set `IncludesConstrainedTypeVariable` for `types`. */
+function hasConstrainedIntersection(types: readonly Type[]): boolean {
+  for (const t of types) {
+    if (isConstrainedIntersection(t)) return true;
+    if ((t.flags & TypeFlags.Union) !== 0 && hasConstrainedIntersection((t as UnionType).types)) return true;
+  }
+  return false;
+}
+
 class TypeSet {
   types: Type[] = [];
   includes = 0;
@@ -1726,20 +1765,26 @@ export function getIntersectionType(c: Checker, types: Type[]): Type {
   return getIntersectionTypeEx(c, types, IntersectionFlags.None, undefined);
 }
 
+/**
+ * The distinct types of an intersection, in the order they were added. Most intersections have a few
+ * types, which a scan of `values` finds faster than a `Set` costs to build, so the set is created only
+ * once the list grows past `INDEX_AFTER`.
+ */
 class OrderedTypeSet {
+  private static readonly INDEX_AFTER = 8;
   readonly values: Type[] = [];
-  private readonly seen = new Set<Type>();
+  private index: Set<Type> | undefined;
   includes = 0;
 
   has(t: Type): boolean {
-    return this.seen.has(t);
+    return this.index !== undefined ? this.index.has(t) : this.values.includes(t);
   }
 
   add(t: Type): void {
-    if (!this.seen.has(t)) {
-      this.seen.add(t);
-      this.values.push(t);
-    }
+    if (this.has(t)) return;
+    this.values.push(t);
+    if (this.index !== undefined) this.index.add(t);
+    else if (this.values.length > OrderedTypeSet.INDEX_AFTER) this.index = new Set(this.values);
   }
 }
 
@@ -2114,7 +2159,8 @@ function addCrossProductIntersections(
   intersections: Type[],
 ): void {
   if (index === types.length) {
-    const t = getIntersectionTypeEx(c, constituents.slice(), flags, undefined);
+    // getIntersectionTypeEx copies the types it keeps, so the buffer is reused for the next combination.
+    const t = getIntersectionTypeEx(c, constituents, flags, undefined);
     if ((t.flags & TypeFlags.Never) === 0) intersections.push(t);
     return;
   }

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

@@ -882,7 +882,7 @@ function getTypeFromTypeQueryNode(c: Checker, node: Node): Type {
   return type;
 }
 
-export function getTupleElementFlags(c: Checker, node: Node): ElementFlags {
+export function getTupleElementFlags(node: Node): ElementFlags {
   switch (node.kind) {
     case SyntaxKind.OptionalType:
       return ElementFlags.Optional;
@@ -901,9 +901,9 @@ export function getTupleElementFlags(c: Checker, node: Node): ElementFlags {
   return ElementFlags.Required;
 }
 
-function getTupleElementInfo(c: Checker, node: Node): TupleElementInfo {
+function getTupleElementInfo(node: Node): TupleElementInfo {
   return new TupleElementInfo(
-    getTupleElementFlags(c, node),
+    getTupleElementFlags(node),
     node.kind === SyntaxKind.NamedTupleMember || node.kind === SyntaxKind.Parameter ? node : undefined,
   );
 }
@@ -934,7 +934,7 @@ function getArrayOrTupleTargetType(c: Checker, node: Node): Type {
     parent.kind === SyntaxKind.TypeOperator && (parent as TypeOperatorNode).operator === SyntaxKind.ReadonlyKeyword;
   if (getArrayElementTypeNode(node) !== undefined) return readonly ? c.globalReadonlyArrayType : c.globalArrayType;
   const elementInfos: TupleElementInfo[] = [];
-  for (const e of (node as TupleTypeNode).elements.nodes) elementInfos.push(getTupleElementInfo(c, e));
+  for (const e of (node as TupleTypeNode).elements.nodes) elementInfos.push(getTupleElementInfo(e));
   return getTupleTargetType(c, elementInfos, readonly);
 }
 
@@ -969,7 +969,7 @@ function getTypeFromArrayOrTupleTypeNode(c: Checker, node: Node): Type {
 }
 
 function hasVariadicTupleElement(c: Checker, node: TupleTypeNode): boolean {
-  for (const e of node.elements.nodes) if ((getTupleElementFlags(c, e) & ElementFlags.Variadic) !== 0) return true;
+  for (const e of node.elements.nodes) if ((getTupleElementFlags(e) & ElementFlags.Variadic) !== 0) return true;
   return false;
 }
 

package/src/compiler/checker-unused.ts

@@ -421,8 +421,9 @@ function checkUnusedClassMembers(c: Checker, node: Node): void {
 function checkUnusedLocalsAndParameters(c: Checker, node: Node): void {
   const locals = getLocals(node);
   if (locals === undefined) return;
-  const variableParents = new Set<Node>();
-  const importClauses = new Map<Node, Node[]>();
+  // Created on the first unused declaration: most scopes have none.
+  let variableParents: Set<Node> | undefined;
+  let importClauses: Map<Node, Node[]> | undefined;
   for (const local of locals.values()) {
     const referenceKinds = c.symbolReferenceKinds.get(getSymbolId(local));
     if ((local.flags & SymbolFlags.TypeParameter) !== 0) {
@@ -438,6 +439,7 @@ function checkUnusedLocalsAndParameters(c: Checker, node: Node): void {
         case SyntaxKind.VariableDeclaration:
         case SyntaxKind.Parameter:
         case SyntaxKind.BindingElement:
+          variableParents ??= new Set<Node>();
           variableParents.add(getRootDeclaration(declaration).parent!);
           break;
         case SyntaxKind.ImportClause:
@@ -445,6 +447,7 @@ function checkUnusedLocalsAndParameters(c: Checker, node: Node): void {
         case SyntaxKind.NamespaceImport:
           if (!isIdentifierThatStartsWithUnderscore(getName(declaration))) {
             const importClause = importClauseFromImported(declaration);
+            importClauses ??= new Map<Node, Node[]>();
             const unuseds = importClauses.get(importClause);
             if (unuseds === undefined) importClauses.set(importClause, [declaration]);
             else unuseds.push(declaration);
@@ -456,12 +459,14 @@ function checkUnusedLocalsAndParameters(c: Checker, node: Node): void {
       }
     }
   }
-  for (const declaration of variableParents) {
-    if (declaration.kind === SyntaxKind.VariableDeclarationList)
-      reportUnusedVariables(c, declaration, (declaration as VariableDeclarationList).declarations.nodes);
-    else reportUnusedVariableDeclarations(c, getParameters(declaration)!.nodes);
-  }
-  for (const [declaration, unuseds] of importClauses) reportUnusedImports(c, declaration as ImportClause, unuseds);
+  if (variableParents !== undefined)
+    for (const declaration of variableParents) {
+      if (declaration.kind === SyntaxKind.VariableDeclarationList)
+        reportUnusedVariables(c, declaration, (declaration as VariableDeclarationList).declarations.nodes);
+      else reportUnusedVariableDeclarations(c, getParameters(declaration)!.nodes);
+    }
+  if (importClauses !== undefined)
+    for (const [declaration, unuseds] of importClauses) reportUnusedImports(c, declaration as ImportClause, unuseds);
 }
 
 function reportUnusedLocal(c: Checker, node: Node, name: string): void {

package/src/compiler/checker.ts

@@ -41,6 +41,7 @@ import {
   PagedIdSet,
   SparseLinkTable,
 } from './link-tables.js';
+import { ExprCheckRecord } from './expr-record.js';
 import { getErrorRangeForNode, getSourceFileOfNode } from './binder-utilities.js';
 import {
   Diagnostic,
@@ -138,7 +139,7 @@ import type { GrammarChecker } from './checker-grammar.js';
 import type { ResolvedModule } from './module-resolution-types.js';
 import type { ModuleSpecifierHost } from './module-specifiers.js';
 import type { PropertyListIndex } from './checker-members.js';
-import { shareThreads, startThreadSharing, type ThreadSharing } from './shared-results.js';
+import { startThreadSharing, type ThreadSharing } from './shared-results.js';
 
 /** What the checker needs from a program. */
 export abstract class CheckerHost {
@@ -410,6 +411,8 @@ export class Checker implements TypeChecking {
   // Counters for type and signature ids.
   typeCount = 0;
   signatureCount = 0;
+  /** Transient symbols the checker created (statistics), as tsgo's `Checker.SymbolCount`. */
+  symbolCount = 0;
   /** Positions of members by name in the tables and lists that lazily instantiated members come from. */
   readonly memberPositionsInLists = new Map<Symbol[], Map<string, number>>();
   /** The property names of the last instantiation of each such list whose table is built on demand. */
@@ -489,6 +492,8 @@ export class Checker implements TypeChecking {
   readonly resolvedSymbols = new CompactLinkTable<Symbol>();
   /** The resolved type of a type node or expression. */
   readonly resolvedTypes = new CompactLinkTable<Type>();
+  /** The type the last completed check of each expression key produced (expr-record.ts). */
+  readonly exprCheckRecord = new ExprCheckRecord();
   /** The resolved signature of a call-like node or a signature declaration. */
   readonly resolvedSignatures = new CompactLinkTable<Signature>();
   /** Merged symbols, indexed by the id of the symbol merged into them. */
@@ -542,6 +547,7 @@ export class Checker implements TypeChecking {
   readonly unionOfUnionTypes = new Map<string, Type>();
   /** `unionOfUnionTypes` without an alias, by both ids and the reduction packed into one number. */
   readonly unionOfUnionTypesById = new Map<number, Type>();
+  readonly unionTypesByInputList = new TypeListCache<Type>();
   readonly intersectionTypes = new TypeListCache<Type>();
   readonly tupleTypes = new Map<string, Type>();
   readonly indexedAccessTypes = new Map<string, Type>();
@@ -717,7 +723,7 @@ export class Checker implements TypeChecking {
   deferDiagnostic(node: Node, report: () => void): void {
     this.deferredDiagnostics.push(report);
     if (this.deferredDiagnosticFiles !== undefined)
-      this.deferredDiagnosticFiles.push(getSourceFileOfNode(node).fileName);
+      this.deferredDiagnosticFiles.push(this.fileIndex.get(getSourceFileOfNode(node)) ?? -1);
   }
 
   /**
@@ -843,7 +849,7 @@ export class Checker implements TypeChecking {
   /** The access flags of the key `getIndexedAccessTypeEx` keeps each indexed access type by. */
   indexedAccessKeyFlags: Map<Type, number> | undefined = undefined;
   /** Where results are shared between checker threads (shared-results.ts): the file of each diagnostic deferred. */
-  deferredDiagnosticFiles: string[] | undefined = undefined;
+  deferredDiagnosticFiles: number[] | undefined = undefined;
 
   constructor(host: CheckerHost) {
     this.host = host;
@@ -1056,7 +1062,9 @@ export class Checker implements TypeChecking {
     mergeAmbientModulesAndAugmentations(this);
     this.modulesMerged = true;
     this.mergeDiagnostics.push(this.diagnostics.takeLog(), this.suggestionDiagnostics.takeLog());
-    if (shareThreads) startThreadSharing(this);
+    // Returns unless this thread was given sharing data (`ThreadSharingData` in its worker data): the
+    // main thread, and every thread of a run that didn't share.
+    startThreadSharing(this);
     if (this.threadSharing !== undefined) {
       this.distributedConditionals = new Map<Type, DistributedConditional>();
       this.distributedByKey = new Map<string, Type>();
@@ -1167,11 +1175,13 @@ export class Checker implements TypeChecking {
   }
 
   newSymbol(flags: SymbolFlags, name: string): Symbol {
+    this.symbolCount++;
     const symbol = new Symbol(flags | SymbolFlags.Transient, name);
     return symbol;
   }
 
   newSymbolWithCheckFlags(flags: SymbolFlags, name: string, checkFlags: CheckFlags): Symbol {
+    this.symbolCount++;
     const symbol = new Symbol(flags | SymbolFlags.Transient, name);
     symbol.checkFlags = checkFlags;
     return symbol;
@@ -1271,6 +1281,7 @@ export function disposeChecker(c: Checker): void {
   c.unionTypes.clear();
   c.unionOfUnionTypes.clear();
   c.unionOfUnionTypesById.clear();
+  c.unionTypesByInputList.clear();
   c.intersectionTypes.clear();
   c.tupleTypes.clear();
   c.indexedAccessTypes.clear();

package/src/compiler/compile-program.ts

@@ -375,6 +375,12 @@ export abstract class CompilerProgram {
     this.emitter = new ProgramEmitter(checked);
   }
 
+  /**
+   * Whether this run checked the program, which `getDiagnosticsOfProgram` sets when it checks it. A run
+   * stopped before checking, by syntax errors or `--noCheck`, keeps no record (`run-records.ts`).
+   */
+  checkedTheProgram = false;
+
   /**
    * The time spent in declaration emit while checking, to count as emit time rather than check time, since
    * the last call. Only an incremental program emits while checking, to compute signatures.
@@ -530,6 +536,8 @@ export function getDiagnosticsOfProgram(
   // Those found by checking come after the semantic diagnostics, as with a single checker.
   for (const d of program.getGlobalDiagnostics(false)) result.push(d);
   if (result.length === configCount) {
+    // With `--noCheck` the checker skips every file: the run checked nothing to sample (`run-records.ts`).
+    if (options.noCheck !== true) program.checkedTheProgram = true;
     const checkStart = performance.now();
     const semantic = program.getSemanticDiagnostics();
     // Declaration emit that computed signatures while checking counts as emit time, as in TypeScript 7.1.

package/src/compiler/decoder.ts

@@ -201,6 +201,7 @@ import {
 import { modifiersToFlags } from './ast-utilities.js';
 import { protocolVersion } from './encoder.js';
 import { SyntaxKind } from './syntax-kind.js';
+import { IdentifierName } from './identifier-name.js';
 
 const nodeSize = 28;
 const headerSize = 64;
@@ -354,7 +355,7 @@ class Decoder {
   createString(kind: SyntaxKind, text: string, common: number): Node {
     switch (kind) {
       case SyntaxKind.Identifier:
-        return new Identifier(text);
+        return new Identifier(new IdentifierName(text));
       case SyntaxKind.PrivateIdentifier:
         return new PrivateIdentifier(text);
       case SyntaxKind.JsxText:

package/src/compiler/doctor-report.ts

@@ -0,0 +1,133 @@
+/**
+ * The report a `tsc-ts doctor` child writes: `TSC_TS_DOCTOR_REPORT` names a file, and `main.ts` writes
+ * what the child's compile measured to it before the process exits. The doctor process reads the file
+ * after the child exits; its own runs are unaffected, since nothing here is set for them.
+ *
+ * The parent times the child and compares its diagnostic output itself, so the report carries what only
+ * the child knows: the phase times, the program's shape, the signals, the run's configuration and the
+ * key the run's record would have.
+ */
+import { writeFileSync } from 'node:fs';
+import { residentMB } from './parallel-check.js';
+
+/** The report path, or `undefined` when this process is not a doctor child. */
+export function doctorReportPath(): string | undefined {
+  const path = process.env.TSC_TS_DOCTOR_REPORT;
+  return path === undefined || path === '' ? undefined : path;
+}
+
+/** What a bound program showed about the cost of checking it (`CheckSignals`), as the report keeps it. */
+export interface DoctorSignals {
+  count: number;
+  ranges: number;
+  library: number;
+  own: number;
+  redundancy: number;
+  declarationShare: number;
+  nodeModulesShare: number;
+  fileShare: number;
+}
+
+/** The program's size, as a run record keeps it. */
+export interface DoctorShape {
+  files: number;
+  chars: number;
+  declarationChars: number;
+  checkChars: number;
+}
+
+/** The phase times of a compile, in milliseconds (`CompileTimes`). */
+export interface DoctorTimes {
+  parseMs: number;
+  checkMs: number;
+  totalMs: number;
+}
+
+/** What this child's compile measured. */
+export interface DoctorCompile {
+  /** The version the executable reports (`help.ts`). */
+  version: string;
+  /** The project's config file, or `undefined` for root files on the command line. */
+  configFile: string | undefined;
+  /** The key a record of this run would have (`run-records.ts`). */
+  key: string;
+  checkers: number;
+  share: boolean;
+  parseThreads: number;
+  times: DoctorTimes;
+  shape: DoctorShape;
+  signals: DoctorSignals | undefined;
+}
+
+/**
+ * What the file holds: the compile the child measured, where it measured one, plus the exit status,
+ * the CPU time and the peak memory. A child that never compiled writes only the last three.
+ */
+export interface DoctorReport {
+  version?: string;
+  configFile?: string;
+  key?: string;
+  checkers?: number;
+  share?: boolean;
+  parseThreads?: number;
+  times?: DoctorTimes;
+  shape?: DoctorShape;
+  signals?: DoctorSignals;
+  status: number;
+  cpuMs: number;
+  peakMB: number;
+}
+
+/** The report the process writes, once its compile measured something. */
+let pending: DoctorCompile | undefined;
+
+/** Records what this child's compile measured; `main.ts` writes it before the process exits. */
+export function setDoctorCompile(compile: DoctorCompile): void {
+  pending = compile;
+}
+
+/**
+ * Exits with `status`, writing the doctor report first where `TSC_TS_DOCTOR_REPORT` names a file. The
+ * compile's exits go through here: the thread drivers in `node-system.ts` exit from their callbacks,
+ * without returning to `main.ts`.
+ */
+export function exitWithDoctorReport(status: number): never {
+  if (doctorReportPath() !== undefined) {
+    const cpu = process.cpuUsage();
+    writeDoctorReport(status, (cpu.user + cpu.system) / 1000);
+  }
+  return process.exit(status);
+}
+
+/**
+ * Writes the report to the file `TSC_TS_DOCTOR_REPORT` names, with the exit status, the CPU time and the
+ * peak memory read at exit. Never throws: a report that cannot be written leaves the parent to time the
+ * child without one.
+ */
+export function writeDoctorReport(status: number, cpuMs: number): void {
+  const path = doctorReportPath();
+  if (path === undefined) return;
+  const compile = pending;
+  const report: DoctorReport =
+    compile === undefined
+      ? { status, cpuMs, peakMB: residentMB()[1] }
+      : {
+          version: compile.version,
+          configFile: compile.configFile,
+          key: compile.key,
+          checkers: compile.checkers,
+          share: compile.share,
+          parseThreads: compile.parseThreads,
+          times: compile.times,
+          shape: compile.shape,
+          signals: compile.signals,
+          status,
+          cpuMs,
+          peakMB: residentMB()[1],
+        };
+  try {
+    writeFileSync(path, JSON.stringify(report) + '\n');
+  } catch {
+    // The parent reports the run without a report file.
+  }
+}