tsc-ts 0.1.1 → 0.1.3

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-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-narrowing.ts

@@ -369,7 +369,7 @@ export function getFlowTypeOfReferenceAt(
   flowContainer: Node | undefined,
   flowNode: FlowNode | undefined,
 ): Type {
-  if (c.flowAnalysisDisabled) return c.errorType;
+  if (c.flowAnalysisDisabled && isInFlowAnalysisStop(c, reference)) return c.errorType;
   if (flowNode === undefined) return declaredType;
   let f: FlowState;
   const stateDepth = c.flowStateDepth;
@@ -396,7 +396,7 @@ export function getFlowTypeOfReferenceAt(
     f.steps >= minFlowWalkSteps &&
     !f.incomplete &&
     !f.positional &&
-    !c.flowAnalysisDisabled &&
+    !(c.flowAnalysisDisabled && isInFlowAnalysisStop(c, reference)) &&
     c.resolutionCycleCount === cycles
   ) {
     const walk = f.walk;
@@ -438,6 +438,7 @@ function complete(f: FlowState, t: Type): Type {
 export function getTypeAtFlowNode(c: Checker, f: FlowState, start: FlowNode): Type {
   if (f.depth === 2000) {
     c.flowAnalysisDisabled = true;
+    c.flowAnalysisDisabledBody = getContainingFlowBody(f.reference);
     reportFlowControlError(c, f.reference);
     return complete(f, c.errorType);
   }
@@ -3148,9 +3149,33 @@ function getContextFreeTypeOfExpression(c: Checker, node: Node): Type {
   return t;
 }
 
-function reportFlowControlError(c: Checker, node: Node): void {
+/** The body whose walk reached the flow limit, or undefined when no body is stopped. */
+function getContainingFlowBody(node: Node): Node | undefined {
   let block: Node | undefined = node;
   while (block !== undefined && !isFunctionOrModuleBlock(block)) block = block.parent;
+  return block;
+}
+
+/** Whether `node` is in the body whose walk reached the flow limit, or in a body it contains. */
+function isInFlowAnalysisStop(c: Checker, node: Node): boolean {
+  const stop = c.flowAnalysisDisabledBody;
+  if (stop === undefined) return false;
+  for (let n: Node | undefined = node; n !== undefined; n = n.parent) if (n === stop) return true;
+  return false;
+}
+
+/**
+ * Ends the narrowing stopped in `body`, whose checks have finished: what follows the body starts over.
+ * A walk that stopped in another body keeps its body's narrowing stopped.
+ */
+export function endFlowAnalysisStop(c: Checker, body: Node): void {
+  if (c.flowAnalysisDisabledBody !== body) return;
+  c.flowAnalysisDisabled = false;
+  c.flowAnalysisDisabledBody = undefined;
+}
+
+function reportFlowControlError(c: Checker, node: Node): void {
+  const block = getContainingFlowBody(node);
   if (block === undefined) return;
   const file = getSourceFileOfNode(node);
   const span = getRangeOfTokenAtPosition(file, getStatements(block)!.pos);
@@ -3165,7 +3190,8 @@ function reportFlowControlError(c: Checker, node: Node): void {
   );
 }
 
-function isFunctionOrModuleBlock(node: Node): boolean {
+/** Whether `node` is the body of a function or a module, where flow analysis starts over (flowAnalysisDisabled). */
+export function isFunctionOrModuleBlock(node: Node): boolean {
   return (
     node.kind === SyntaxKind.SourceFile ||
     node.kind === SyntaxKind.ModuleBlock ||

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

@@ -132,6 +132,11 @@ import { checkContextualDeprecations, checkDeprecatedTypeReference } from './che
  * identifiers, which need the whole file checked first.
  */
 export function checkSourceFile(c: Checker, file: SourceFile, checkUnused = false): void {
+  // A source file is a module body: narrowing stopped by a body too large for control flow analysis
+  // (flowAnalysisDisabled, checker-narrowing.ts) starts over in the next check. A checker checks many files
+  // (parallel-check.ts), so its diagnostics of a file must not depend on the files it checked before it.
+  c.flowAnalysisDisabled = false;
+  c.flowAnalysisDisabledBody = undefined;
   const links = c.nodeLinks(file);
   if ((links.flags & NodeCheckFlags.TypeChecked) === 0) {
     links.flags |= NodeCheckFlags.TypeChecked;
@@ -141,6 +146,9 @@ export function checkSourceFile(c: Checker, file: SourceFile, checkUnused = fals
     links.flags |= NodeCheckFlags.UnusedChecked;
     checkUnusedIdentifiers(c, file);
   }
+  // Every body of the file has finished its checks; a stop recorded for one of them ends with the file.
+  c.flowAnalysisDisabled = false;
+  c.flowAnalysisDisabledBody = undefined;
 }
 
 function checkSourceFileWorker(c: Checker, file: SourceFile): void {
@@ -176,6 +184,10 @@ function checkSourceFileWorker(c: Checker, file: SourceFile): void {
  */
 export function checkSourceFileRange(c: Checker, file: SourceFile, start: number, end: number): boolean {
   const statements = getStatements(file)!.nodes;
+  // A range of a file's statements is part of its module body: narrowing stopped by a body too large for
+  // control flow analysis (flowAnalysisDisabled, checker-narrowing.ts) starts over in the next range.
+  c.flowAnalysisDisabled = false;
+  c.flowAnalysisDisabledBody = undefined;
   c.fileBeingChecked = file;
   for (let i = start; i < end; i++) checkSourceElement(c, statements[i]!);
   checkDeferredNodes(c, file);
@@ -191,6 +203,9 @@ export function checkSourceFileRange(c: Checker, file: SourceFile, start: number
   produceDeferredDiagnostics(c);
   // Deferred nodes of a later range are queued again (checkNodeDeferred).
   c.nodeLinks(file).deferredNodes = undefined;
+  // The range's bodies have finished their checks; a stop recorded for one of them ends with the range.
+  c.flowAnalysisDisabled = false;
+  c.flowAnalysisDisabledBody = undefined;
   return c.diagnostics.forFile(file.fileName).length > 0;
 }
 
@@ -639,7 +654,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-statements.ts

@@ -42,7 +42,7 @@ import {
   isTypeEqualityComparableTo,
 } from './checker-operators.js';
 import { checkTypeComparableTo, isTypeAssignableTo } from './relations.js';
-import { isReachableFlowNode } from './checker-narrowing.js';
+import { endFlowAnalysisStop, isFunctionOrModuleBlock, isReachableFlowNode } from './checker-narrowing.js';
 import { getIndexType, isTypeAssignableToKindEx as isTypeAssignableToKind } from './checker-type-operators.js';
 import { getExtractStringType } from './checker-symbol-types.js';
 import { checkSourceElement } from './checker-source-file.js';
@@ -57,7 +57,15 @@ import { typeToString } from './type-printer.js';
 import { TypeFacts, getNonNullableType, hasTypeFacts } from './checker-flow.js';
 
 export function checkBlock(c: Checker, node: Node): void {
-  for (const s of getStatements(node)!.nodes) checkSourceElement(c, s);
+  const statements = getStatements(node)!.nodes;
+  if (!isFunctionOrModuleBlock(node)) {
+    for (const s of statements) checkSourceElement(c, s);
+    return;
+  }
+  // A body too large for control flow analysis stops narrowing in the rest of that body only
+  // (flowAnalysisDisabled, checker-narrowing.ts); what follows the body starts over.
+  for (const s of statements) checkSourceElement(c, s);
+  endFlowAnalysisStop(c, node);
 }
 
 export function checkExpressionStatement(c: Checker, node: Node): void {

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

@@ -1765,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);
   }
 }
 
@@ -2153,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

@@ -411,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. */
@@ -753,6 +755,8 @@ export class Checker implements TypeChecking {
 
   // Control flow analysis
   flowAnalysisDisabled = false;
+  /** The body whose walk reached the flow limit (flowAnalysisDisabled), until its checks finish. */
+  flowAnalysisDisabledBody: Node | undefined = undefined;
   inlineLevel = 0;
   /**
    * Shared flow nodes cached by the walks in progress, with their types: the first
@@ -1173,11 +1177,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;

package/src/compiler/file-loader.ts

@@ -131,6 +131,12 @@ export class CompilerHost extends ModuleResolutionHost {
     return this.fs.getAccessibleEntries(path).directories;
   }
 
+  /**
+   * The metadata of the file `FileLoader` is parsing, which it computes from the file's package scope
+   * before it parses it; a host that walks the grammar of the parsed file reads it (parse-thread.ts).
+   */
+  loadingSourceFileMetadata: SourceFileMetadata | undefined = undefined;
+
   /** Parses a file, or returns `undefined` if it can't be read. */
   getSourceFile(
     fileName: string,
@@ -1222,6 +1228,8 @@ export class FileLoader {
         ? libFileMetadata
         : (loaded?.metadata ?? this.loadSourceFileMetadata(task.normalizedFilePath));
     const options = this.mapper.getCompilerOptionsForFile(task.path, task.normalizedFilePath);
+    // For the host that walks the grammar of the file as it parses it (parse-thread.ts).
+    this.host.loadingSourceFileMetadata = task.metadata;
     const file = this.host.getSourceFile(
       task.normalizedFilePath,
       task.path,

package/src/compiler/parallel-check.ts

@@ -199,6 +199,11 @@ export class CheckerResult {
     readonly units: number[] = [],
     /** Those of `units` after which its checker had diagnostics in their file (`checkSourceFileRange`). */
     readonly reportingUnits: number[] = [],
+    /**
+     * The types, instantiations and transient symbols its checker created, which `--diagnostics` adds to
+     * the main thread's (`CheckedProgram.addCheckerCounts`); empty for a result without a checker of its own.
+     */
+    readonly counts: number[] = [],
   ) {}
 }
 
@@ -243,6 +248,7 @@ export type PackedResult = {
   readonly reserved: number[];
   readonly units: Int32Array;
   readonly reportingUnits: Int32Array;
+  readonly counts: number[];
 };
 
 class ResultPacker {
@@ -346,6 +352,7 @@ export function packResult(result: CheckerResult, program: Program): PackedResul
     reserved: result.reserved,
     units: Int32Array.from(result.units),
     reportingUnits: Int32Array.from(result.reportingUnits),
+    counts: result.counts,
   };
 }
 
@@ -475,6 +482,7 @@ export function unpackResult(
     emits,
     Array.from(packed.units),
     Array.from(packed.reportingUnits),
+    packed.counts,
   );
 }
 
@@ -1928,6 +1936,7 @@ export function checkFromQueue(
     emits,
     unitsDone,
     reportingUnits,
+    onMainThread ? [] : [checked.checker.typeCount, checked.checker.totalInstantiations, checked.checker.symbolCount],
   );
 }
 
@@ -2152,7 +2161,8 @@ function checkSignals(
   }
   signals.library = library / ranges;
   signals.own = own / ranges;
-  signals.redundancy = (library - unionChars) / (library + own);
+  // Every range can be empty (all of a program's files in the shared queue), so `library + own` can be 0.
+  signals.redundancy = library + own === 0 ? 0 : (library - unionChars) / (library + own);
   signals.declarationShare = declarationFiles / files.length;
   signals.nodeModulesShare = nodeModulesFiles / files.length;
   if (config !== undefined) config.signals = signals;
@@ -2326,6 +2336,7 @@ export function startParallelCheck(
     done(performance.now() - start);
   };
   const record = (result: CheckerResult): void => {
+    checked.addCheckerCounts(result.counts);
     if (declarationsTo !== undefined) {
       for (let k = 0; k < result.declarations.length; k++) declarationsTo[result.files[k]!] = result.declarations[k]!;
       if (trace)
@@ -2569,6 +2580,7 @@ class Revival {
       copy.emits.map((emit) => this.emit(emit)),
       copy.units,
       copy.reportingUnits,
+      copy.counts,
     );
   }
 

package/src/compiler/parse-thread.ts

@@ -6,10 +6,11 @@
 import { publish } from '@scriptc/threads';
 import { type ExternalModuleIndicatorOptions, ParseOptions, ScriptKind, type SourceFile } from './ast.js';
 import { bindSourceFile } from './binder.js';
+import { checkGrammarSourceFileInParseThread } from './checker-grammar.js';
 import { useThreadTextCaches } from './diagnostics.js';
 import { CompilerHost, FileLoader } from './file-loader.js';
 import { computeHash } from './incremental.js';
-import { isIncremental } from './options.js';
+import { type CompilerOptions, isIncremental } from './options.js';
 import type { FileSystem } from './file-system.js';
 import {
   fileSize,
@@ -29,6 +30,18 @@ class PreparingHost extends CompilerHost {
   prepared: PreparedFile[] = [];
   /** Whether the files' build info versions are computed (an incremental program). */
   computesVersions = false;
+  /**
+   * Whether the files the loader parses here run their grammar checks before they are published. The
+   * walk is the checker's, run off the checking threads (checker-grammar.ts).
+   */
+  grammarChecks = true;
+  /** The program's options, which the grammar checks of a file are given. */
+  readonly options: CompilerOptions;
+
+  constructor(fs: FileSystem, currentDirectory: string, defaultLibraryPath: string, options: CompilerOptions) {
+    super(fs, currentDirectory, defaultLibraryPath);
+    this.options = options;
+  }
   readMs = 0;
   parseMs = 0;
   bindMs = 0;
@@ -49,6 +62,12 @@ class PreparingHost extends CompilerHost {
     );
     const t2 = timeline ? performance.now() : 0;
     bindSourceFile(file);
+    // The checker does not check the declaration files `skipLibCheck` names, so it does not walk their
+    // grammar either. The walk reads the metadata the loader computed for the file, which is the one the
+    // checking thread reads it with, so it looks up no package.json the load has not looked up.
+    const metadata = this.loadingSourceFileMetadata;
+    if (this.grammarChecks && metadata !== undefined && !(this.options.skipLibCheck === true && file.isDeclarationFile))
+      checkGrammarSourceFileInParseThread(file, this.options, metadata);
     // Published now, while its nodes are in cache: the chunk's publish (`ParseThread.load`) then skips
     // them, where walking the whole chunk's files at once reads each node from memory again.
     publish(file);
@@ -85,11 +104,14 @@ export class ParseThread {
   private sentPackageJsons = 0;
 
   constructor(config: ParsedCommandLine, fs: FileSystem, currentDirectory: string, defaultLibraryPath: string) {
-    this.host = new PreparingHost(fs, currentDirectory, defaultLibraryPath);
+    this.host = new PreparingHost(fs, currentDirectory, defaultLibraryPath, config.options);
     // The versions of an incremental program's files are computed here rather than one after another
     // on the main thread (programToSnapshot, incremental.ts).
     this.host.computesVersions = isIncremental(config.options);
     this.loader = new FileLoader(this.host, config);
+    // A program that does not check has no grammar diagnostics to report. An incremental program checks
+    // the files a change affects and parses all of them, so the walk stays with the checker there.
+    this.host.grammarChecks = config.options.noCheck !== true && !isIncremental(config.options);
     // The files this thread loads are published with their chunk: text caches it computes later (of
     // declaration files, which the parser leaves out) go to copies.
     useThreadTextCaches();

package/src/compiler/program-checker.ts

@@ -248,6 +248,28 @@ export class CheckedProgram {
     this.reportingChecker = undefined;
   }
 
+  /** Adds the counts a checker thread sent (`CheckerResult.counts`): types, instantiations, symbols. */
+  addCheckerCounts(counts: readonly number[]): void {
+    if (counts.length < 3) return;
+    this.threadTypeCount += counts[0]!;
+    this.threadInstantiations += counts[1]!;
+    this.threadSymbolCount += counts[2]!;
+  }
+
+  /**
+   * The types, instantiations and transient symbols of every checker of the program: this thread's and
+   * the checker threads', as tsgo's `Program.TypeCount`, `InstantiationCount` and `SymbolCount` add them up.
+   * Reading them doesn't create this thread's checker.
+   */
+  checkerCounts(): { types: number; instantiations: number; symbols: number } {
+    const own = this.reportingChecker;
+    return {
+      types: (own === undefined ? 0 : own.typeCount) + this.threadTypeCount,
+      instantiations: (own === undefined ? 0 : own.totalInstantiations) + this.threadInstantiations,
+      symbols: (own === undefined ? 0 : own.symbolCount) + this.threadSymbolCount,
+    };
+  }
+
   getBindDiagnostics(file: SourceFile | undefined): Diagnostic[] {
     return this.collect(file, (f) => f.bindDiagnostics);
   }
@@ -272,6 +294,12 @@ export class CheckedProgram {
    */
   referenceThreads = 1;
   readonly parallelGlobalDiagnostics: Diagnostic[] = [];
+  /** The types checker threads created (`CheckerResult.counts`), which `--diagnostics` adds to `checker`'s. */
+  threadTypeCount = 0;
+  /** The instantiations checker threads made. */
+  threadInstantiations = 0;
+  /** The transient symbols checker threads created. */
+  threadSymbolCount = 0;
   /**
    * Whether the semantic diagnostics of a file include the global diagnostics its checker found while
    * checking it, as an incremental program caches them (IncrementalProgram). Such a program doesn't report

package/src/compiler/run-records.ts

@@ -282,10 +282,17 @@ export function readRecord(file: string, now: number = Math.floor(Date.now() / 1
   return dropOldSamples(record, now);
 }
 
+/**
+ * A parsed value whose fields are read as `unknown` until they are checked. A native build checks a
+ * cast to a record type such as `Partial<RunRecord>` when it converts the value, and throws on a field
+ * of the wrong type, so a malformed record file would end the run instead of being ignored.
+ */
+type Unchecked<T> = { [K in keyof T]?: unknown };
+
 /** `parsed` as a record, or `undefined` where it is not one this build writes. */
 function recordOf(parsed: unknown): RunRecord | undefined {
   if (typeof parsed !== 'object' || parsed === null) return undefined;
-  const r = parsed as Partial<RunRecord>;
+  const r = parsed as Unchecked<RunRecord>;
   if (r.format !== recordFormat || typeof r.runs !== 'number' || !isShape(r.shape) || !isChoice(r.chosen))
     return undefined;
   const samples = Array.isArray(r.samples) ? r.samples.filter(isSample) : [];
@@ -304,7 +311,7 @@ function recordOf(parsed: unknown): RunRecord | undefined {
 
 function isShape(value: unknown): value is RecordShape {
   if (typeof value !== 'object' || value === null) return false;
-  const s = value as Partial<RecordShape>;
+  const s = value as Unchecked<RecordShape>;
   return (
     isNumber(s.files) &&
     isNumber(s.chars) &&
@@ -318,7 +325,7 @@ function isShape(value: unknown): value is RecordShape {
 
 function isChoice(value: unknown): value is RecordChoice {
   if (typeof value !== 'object' || value === null) return false;
-  const c = value as Partial<RecordChoice>;
+  const c = value as Unchecked<RecordChoice>;
   return (
     isNumber(c.checkers) &&
     typeof c.share === 'boolean' &&
@@ -331,7 +338,7 @@ function isChoice(value: unknown): value is RecordChoice {
 
 function isRejection(value: unknown): value is RecordRejection {
   if (typeof value !== 'object' || value === null) return false;
-  const r = value as Partial<RecordRejection>;
+  const r = value as Unchecked<RecordRejection>;
   return (
     isNumber(r.checkers) &&
     typeof r.share === 'boolean' &&
@@ -342,7 +349,7 @@ function isRejection(value: unknown): value is RecordRejection {
 
 function isSample(value: unknown): value is RecordSample {
   if (typeof value !== 'object' || value === null) return false;
-  const s = value as Partial<RecordSample>;
+  const s = value as Unchecked<RecordSample>;
   return (
     isNumber(s.run) &&
     isNumber(s.at) &&