tsc-ts 0.0.10 → 0.1.0

package/src/compiler/help.ts

@@ -8,18 +8,24 @@ import {
   buildOptionDeclarations,
   optionDeclarations,
   optionsForBuild,
-  optionsForWatch,
   sameEnumValue,
   type OptionDeclaration,
 } from './option-declarations.js';
 import type { System } from './tsc-cli.js';
 
-export const version = '7.0.2';
+export const version = '7.1.0-beta';
 
-/** Whether output gets colors: `NO_COLOR` and `FORCE_COLOR` override the TTY check. */
+/**
+ * Whether output gets colors. As in Node, a set `FORCE_COLOR` decides: on when empty, `1`, `2`, `3` or `true`, off
+ * otherwise. Then `NO_COLOR` or `TERM=dumb` turn colors off, else they follow the TTY check.
+ */
 export function defaultIsPretty(sys: System): boolean {
+  if (sys.hasEnvironmentVariable('FORCE_COLOR')) {
+    const forceColor = sys.getEnvironmentVariable('FORCE_COLOR');
+    return forceColor === '' || forceColor === '1' || forceColor === '2' || forceColor === '3' || forceColor === 'true';
+  }
   if (sys.getEnvironmentVariable('NO_COLOR') !== '') return false;
-  if (sys.getEnvironmentVariable('FORCE_COLOR') !== '') return true;
+  if (sys.getEnvironmentVariable('TERM') === 'dumb') return false;
   return sys.writeOutputIsTTY;
 }
 
@@ -262,16 +268,6 @@ function printAllHelp(writer: HelpWriter, options: readonly OptionDeclaration[])
     undefined,
     learnMore(writer),
   );
-  out += sectionOutput(
-    writer,
-    writer.text(Diagnostics.WATCH_OPTIONS),
-    optionsForWatch,
-    false,
-    writer.text(
-      Diagnostics.Including_watch_w_will_start_watching_the_current_project_for_the_file_changes_Once_set_you_can_config_watch_mode_with_Colon,
-    ),
-    undefined,
-  );
   out += sectionOutput(
     writer,
     writer.text(Diagnostics.BUILD_OPTIONS),

package/src/compiler/incremental.ts

@@ -41,6 +41,7 @@ import {
   modeMismatchDetails,
   moduleNotFoundDetails,
   resolveExternalModuleName,
+  getImportAttributesTypeForModuleSpecifier,
 } from './checker-modules.js';
 import { getSymbolAtLocation } from './checker-services.js';
 import { resolveAlias } from './checker-symbols.js';
@@ -1231,7 +1232,17 @@ function addOwnReferencedFiles(checked: CheckedProgram, file: SourceFile, refere
   // call that does not initialize a variable (`exports.a = require("./a").a`), so its build info leaves out that
   // module and its incremental builds keep outputs that depend on it.
   for (const importName of file.imports) {
-    addReferencedFilesFromSymbol(file, referenced, resolveExternalModuleName(checker, importName, importName, true));
+    addReferencedFilesFromSymbol(
+      file,
+      referenced,
+      resolveExternalModuleName(
+        checker,
+        importName,
+        importName,
+        true,
+        getImportAttributesTypeForModuleSpecifier(checker, importName),
+      ),
+    );
   }
   const sourceFileDirectory = getDirectoryPath(file.fileName);
   for (const reference of file.referencedFiles) {
@@ -1275,9 +1286,16 @@ function programToSnapshot(checked: CheckedProgram, oldSnapshot: Snapshot | unde
   // Reuse from the old state.
   if (oldSnapshot !== undefined) {
     if (options.composite === true) snapshot.latestChangedDtsFile = oldSnapshot.latestChangedDtsFile;
-    for (const path of oldSnapshot.changedFilesSet) snapshot.changedFilesSet.add(path);
-    for (const [path, kind] of oldSnapshot.affectedFilesPendingEmit) snapshot.affectedFilesPendingEmit.set(path, kind);
     snapshot.buildInfoEmitPending = oldSnapshot.buildInfoEmitPending;
+    // Changes and pending emit of files no longer in the program are dropped, which changes the build info.
+    for (const path of oldSnapshot.changedFilesSet) {
+      if (program.getSourceFileByPath(path) !== undefined) snapshot.changedFilesSet.add(path);
+      else snapshot.buildInfoEmitPending = true;
+    }
+    for (const [path, kind] of oldSnapshot.affectedFilesPendingEmit) {
+      if (program.getSourceFileByPath(path) !== undefined) snapshot.affectedFilesPendingEmit.set(path, kind);
+      else snapshot.buildInfoEmitPending = true;
+    }
     snapshot.hasErrorsFromOldState = oldSnapshot.hasErrors;
     snapshot.hasSemanticErrorsFromOldState = oldSnapshot.hasSemanticErrors;
     const oldPackageJsons = oldSnapshot.packageJsons;
@@ -1425,13 +1443,23 @@ function programToSnapshot(checked: CheckedProgram, oldSnapshot: Snapshot | unde
   if (oldSnapshot !== undefined) {
     for (const [path, oldInfo] of oldSnapshot.fileInfos) {
       if (snapshot.fileInfos.has(path)) continue;
-      if (oldInfo.affectsGlobalScope) {
-        for (const file of snapshot.getAllFilesExcludingDefaultLibraryFile(program, undefined)) {
-          snapshot.addFileToChangeSet(file.path);
-        }
-        globalFileRemoved = true;
-      } else snapshot.buildInfoEmitPending = true;
-      break;
+      snapshot.buildInfoEmitPending = true;
+      snapshot.changedFilesSet.delete(path);
+      snapshot.affectedFilesPendingEmit.delete(path);
+      if (oldInfo.affectsGlobalScope) globalFileRemoved = true;
+    }
+    if (globalFileRemoved) invalidateGlobalScope(checked, snapshot);
+  }
+
+  // A file that no longer affects the global scope changes it as its removal would.
+  if (oldSnapshot !== undefined && !globalFileRemoved) {
+    for (const [path, oldInfo] of oldSnapshot.fileInfos) {
+      if (!oldInfo.affectsGlobalScope) continue;
+      const info = snapshot.fileInfos.get(path);
+      if (info !== undefined && !info.affectsGlobalScope) {
+        invalidateGlobalScope(checked, snapshot);
+        break;
+      }
     }
   }
 
@@ -1460,6 +1488,19 @@ function programToSnapshot(checked: CheckedProgram, oldSnapshot: Snapshot | unde
   return snapshot;
 }
 
+/**
+ * After a change to the global scope, every file but the default libraries is changed, and the default
+ * libraries that are checked are checked again.
+ */
+function invalidateGlobalScope(checked: CheckedProgram, snapshot: Snapshot): void {
+  const program = checked.program;
+  snapshot.buildInfoEmitPending = true;
+  for (const file of program.getSourceFiles()) {
+    if (!program.isSourceFileDefaultLibrary(file.path)) snapshot.addFileToChangeSet(file.path);
+    else if (!checked.skipTypeChecking(file, true)) snapshot.semanticDiagnosticsPerFile.delete(file.path);
+  }
+}
+
 // ---- Affected files
 
 class AffectedFilesHandler {
@@ -1510,7 +1551,12 @@ class AffectedFilesHandler {
   private computeDtsSignature(file: SourceFile): string {
     const known = this.incremental.signatures.get(file.path);
     if (known !== undefined) return known;
-    return declarationSignature(this.incremental.emitter, file, this.snapshot.options);
+    const done = this.incremental.beginNestedEmit();
+    try {
+      return declarationSignature(this.incremental.emitter, file, this.snapshot.options);
+    } finally {
+      done();
+    }
   }
 
   updateShapeSignature(file: SourceFile, useFileVersionAsSignature: boolean): boolean {
@@ -1519,7 +1565,10 @@ class AffectedFilesHandler {
     if (info === undefined) return false;
     const previous = info.signature;
     let signature = '';
-    if (!file.isDeclarationFile && !useFileVersionAsSignature) signature = this.computeDtsSignature(file);
+    // A JSON file has no declaration output, so its version is its signature, which invalidates its importers.
+    if (!file.isDeclarationFile && !isJsonSourceFile(file) && !useFileVersionAsSignature) {
+      signature = this.computeDtsSignature(file);
+    }
     if (signature === '') signature = info.version;
     this.updatedSignatures.set(file.path, signature);
     return signature !== previous;
@@ -1549,7 +1598,7 @@ class AffectedFilesHandler {
     const info = this.snapshot.fileInfos.get(file.path);
     if (info !== undefined && info.affectsGlobalScope) {
       this.hasAllFilesExcludingDefaultLibraryFile = true;
-      this.snapshot.getAllFilesExcludingDefaultLibraryFile(this.program, file);
+      return this.snapshot.getAllFilesExcludingDefaultLibraryFile(this.program, file);
     }
     if (this.snapshot.options.isolatedModules === true) return [file];
     const seen = this.forEachFileReferencedBy(file, (currentFile) => {
@@ -1966,7 +2015,7 @@ class EmitFilesHandler {
       results.push(
         declarations !== undefined
           ? this.writeThreadOutputs(file, declarations, writer)
-          : program.emitter.emit([file], EmitOnly.Dts, wrapped),
+          : program.emitter.emit([file], emitOnly === EmitOnly.Dts ? EmitOnly.Dts : EmitOnly.DtsAfterJs, wrapped),
       );
     return combineEmitResults(results);
   }
@@ -2558,6 +2607,7 @@ export class IncrementalProgram extends CompilerProgram {
     readonly signatures: ReadonlyMap<string, string> = new Map(),
   ) {
     super(checked, times);
+    checked.globalsInFileDiagnostics = true;
     this.snapshot = programToSnapshot(checked, oldSnapshot);
   }
 
@@ -2565,6 +2615,25 @@ export class IncrementalProgram extends CompilerProgram {
     return this.snapshot.hasChangedDtsFile;
   }
 
+  /** Time spent in declaration emit for signatures while checking (`computeDtsSignature`), not yet taken. */
+  private nestedEmitTime = 0;
+  private nestedEmitDepth = 0;
+  private nestedEmitStart = 0;
+
+  /** Starts timing a nested declaration emit; returns the function that ends it. */
+  beginNestedEmit(): () => void {
+    if (this.nestedEmitDepth++ === 0) this.nestedEmitStart = performance.now();
+    return () => {
+      if (--this.nestedEmitDepth === 0) this.nestedEmitTime += performance.now() - this.nestedEmitStart;
+    };
+  }
+
+  override takeNestedEmitTime(): number {
+    const time = this.nestedEmitTime;
+    this.nestedEmitTime = 0;
+    return time;
+  }
+
   /**
    * The global diagnostics found before `filesToCheck` computed the affected files, which the program
    * reports before its semantic diagnostics (`getGlobalDiagnostics(false)`), as when they are computed
@@ -2697,10 +2766,9 @@ export class IncrementalProgram extends CompilerProgram {
   emit(writer: OutputWriter): EmitResult {
     const options = this.snapshot.options;
     let result: EmitResult | undefined;
-    if (options.noEmit === true) {
-      result = new EmitResult();
-      result.emitSkipped = true;
-    } else result = handleNoEmitOnError(this);
+    // A `noEmit` program emits only its build info, and its emit is not skipped (tsgo's `HandleNoEmitOptions`).
+    if (options.noEmit === true) result = new EmitResult();
+    else result = handleNoEmitOnError(this);
     if (result !== undefined) {
       const buildInfoResult = this.emitBuildInfo(writer);
       if (buildInfoResult !== undefined) {

package/src/compiler/init.ts

@@ -2,12 +2,7 @@
  * The tsconfig.json written by `tsc --init`.
  */
 import { Diagnostics, localizeMessage, type DiagnosticMessage, type Locale } from './diagnostics.js';
-import {
-  compilerOptionsByName,
-  sameEnumValue,
-  watchOptionsByName,
-  type OptionDeclaration,
-} from './option-declarations.js';
+import { compilerOptionsByName, sameEnumValue, type OptionDeclaration } from './option-declarations.js';
 import { JsxEmit, ModuleDetectionKind, ModuleKind, ScriptTarget, type OptionValue } from './options.js';
 
 const enum Commented {
@@ -124,7 +119,7 @@ class ConfigWriter {
 }
 
 function formatValue(name: string, value: OptionValue): string {
-  const option = compilerOptionsByName.get(name) ?? watchOptionsByName.get(name);
+  const option = compilerOptionsByName.get(name);
   if (value === null) return 'null';
   if (typeof value === 'boolean') return value ? 'true' : 'false';
   if (typeof value === 'number' || typeof value === 'string') return formatScalar(value, option);

package/src/compiler/instantiation.ts

@@ -43,6 +43,7 @@ import {
   newTypeMapper,
   SimpleTypeMapper,
   TypeListCache,
+  getMappedType,
 } from './checker-types.js';
 import {
   IntersectionFlags,
@@ -87,6 +88,7 @@ import {
   type Symbol,
   SymbolFlags,
 } from './symbol.js';
+import { symbolToString } from './type-printer.js';
 
 // ---- Mappers that need the checker
 
@@ -104,8 +106,8 @@ export class CompositeTypeMapper extends TypeMapper {
   }
 
   map(type: Type): Type {
-    const t1 = this.m1.map(type);
-    return t1 !== type ? instantiateType(this.c, t1, this.m2) : this.m2.map(type);
+    const t1 = getMappedType(type, this.m1);
+    return t1 !== type ? instantiateType(this.c, t1, this.m2) : getMappedType(type, this.m2);
   }
 }
 
@@ -202,23 +204,37 @@ export function instantiateTypeWithAlias(
   }
   if (!could && (type.alias === undefined || !aliasCouldContainTypeVariables(c, type))) return type;
   if (c.instantiationDepth === 100 || c.instantiationCount >= 5000000) {
-    // Probably infinitely expanding generic types; stop with the error type.
-    c.error(c.currentNode, Diagnostics.Type_instantiation_is_excessively_deep_and_possibly_infinite);
+    // Probably infinitely expanding generic types; stop with the error type, naming the types whose
+    // instantiations nest three or more times.
+    const circularTypeNames = getCircularTypeNames(c);
+    if (circularTypeNames.length === 1)
+      c.error(c.currentNode, Diagnostics.Instantiations_of_type_0_appear_infinitely_circular, circularTypeNames[0]!);
+    else if (circularTypeNames.length > 1)
+      c.error(
+        c.currentNode,
+        Diagnostics.Instantiations_of_the_following_types_appear_infinitely_circular_Colon_0,
+        quotedAndCommaSeparated(circularTypeNames),
+      );
+    else c.error(c.currentNode, Diagnostics.Type_instantiation_is_excessively_deep_and_possibly_infinite);
     return c.errorType;
   }
-  const depth = c.activeMapperDepth;
-  const activeMappers = c.activeMappers;
-  let index = depth - 1;
-  while (index >= 0 && activeMappers[index]! !== mapper) index--;
+  const depth = c.activeMapperDepth | 0;
+  const mapperId = mapper.id | 0;
+  let index = (depth - 1) | 0;
+  while (index >= 0 && c.activeMapperIds[index]! !== mapperId) index = (index - 1) | 0;
   if (index === -1) {
     // A newly active mapper has no cached instantiations; its cache is created when a nested
     // instantiation with the same mapper stores one.
-    if (depth < activeMappers.length) {
-      activeMappers[depth] = mapper;
+    if (depth === c.activeMapperIds.length) {
+      const grown = new Int32Array(depth * 2);
+      grown.set(c.activeMapperIds);
+      c.activeMapperIds = grown;
+    }
+    c.activeMapperIds[depth] = mapperId;
+    if (depth < c.activeMapperCaches.length) {
       c.activeMapperCaches[depth] = undefined;
       c.activeMapperAliasCaches[depth] = undefined;
     } else {
-      activeMappers.push(mapper);
       c.activeMapperCaches.push(undefined);
       c.activeMapperAliasCaches.push(undefined);
     }
@@ -236,7 +252,11 @@ export function instantiateTypeWithAlias(
   }
   c.instantiationCount++;
   c.totalInstantiations++;
-  c.instantiationDepth++;
+  const instantiationDepth = c.instantiationDepth;
+  const instantiationStack = c.instantiationStack;
+  if (instantiationDepth < instantiationStack.length) instantiationStack[instantiationDepth] = type;
+  else instantiationStack.push(type);
+  c.instantiationDepth = instantiationDepth + 1;
   const result = instantiateTypeWorker(c, type, mapper, alias);
   if (index === -1) {
     // The mapper's slot stays until it is reused; its caches are released now.
@@ -274,6 +294,32 @@ export function instantiateTypeWithAlias(
   return result;
 }
 
+/**
+ * The names of the types that are instantiated three or more times on the current instantiation stack, by
+ * their alias where they have one, in the order they reach the third, each once.
+ */
+function getCircularTypeNames(c: Checker): string[] {
+  const counts = new Map<Type, number>();
+  const names: string[] = [];
+  const stack = c.instantiationStack;
+  for (let i = 0; i < c.instantiationDepth; i++) {
+    const t = stack[i]!;
+    const count = (counts.get(t) ?? 0) + 1;
+    counts.set(t, count);
+    if (count !== 3) continue;
+    const symbol = t.alias !== undefined ? t.alias.symbol : t.symbol;
+    if (symbol === undefined || symbol.name.length === 0 || symbol.name.charCodeAt(0) === 0xfffe) continue;
+    const name = symbolToString(c, symbol);
+    if (!names.includes(name)) names.push(name);
+  }
+  return names;
+}
+
+/** `'a', 'b', 'c'`. */
+export function quotedAndCommaSeparated(items: readonly string[]): string {
+  return items.map((item) => "'" + item + "'").join(', ');
+}
+
 function aliasCouldContainTypeVariables(c: Checker, type: Type): boolean {
   const alias = type.alias;
   if (alias === undefined || alias.typeArguments.length === 0) return false;
@@ -358,7 +404,7 @@ function isNonGenericTopLevelType(type: Type): boolean {
 
 function instantiateTypeWorker(c: Checker, type: Type, mapper: TypeMapper, alias: TypeAlias | undefined): Type {
   const flags = type.flags;
-  if ((flags & TypeFlags.TypeParameter) !== 0) return mapper.map(type);
+  if ((flags & TypeFlags.TypeParameter) !== 0) return getMappedType(type, mapper);
   if ((flags & TypeFlags.Object) !== 0) {
     const objectFlags = type.objectFlags;
     if ((objectFlags & (ObjectFlags.Reference | ObjectFlags.Anonymous | ObjectFlags.Mapped)) === 0) return type;
@@ -447,7 +493,7 @@ function getObjectTypeInstantiation(
   mapper: TypeMapper,
   alias: TypeAlias | undefined,
 ): Type {
-  if ((type.objectFlags & ObjectFlags.Reference) === 0 && c.withoutOuterTypeParameters.get(type.id) !== 0) return type;
+  if ((type.objectFlags & ObjectFlags.Reference) === 0 && c.withoutOuterTypeParameters.has(type.id)) return type;
   let declaration: Node;
   if ((type.objectFlags & ObjectFlags.Reference) !== 0) declaration = (type as TypeReference).node!;
   else if ((type.objectFlags & ObjectFlags.InstantiationExpressionType) !== 0)
@@ -483,7 +529,7 @@ function getObjectTypeInstantiation(
     links.outerTypeParameters = typeParameters;
   }
   if (typeParameters.length === 0) {
-    if ((type.objectFlags & ObjectFlags.Reference) === 0) c.withoutOuterTypeParameters.set(type.id, 1);
+    if ((type.objectFlags & ObjectFlags.Reference) === 0) c.withoutOuterTypeParameters.add(type.id);
     return type;
   }
   // The type arguments, mapped as `combineTypeMappers(c, type.mapper, mapper)` maps them, into a
@@ -491,10 +537,10 @@ function getObjectTypeInstantiation(
   const typeMapper = type.mapper;
   const mapped = c.freeTypeLists.pop() ?? [];
   for (const tp of typeParameters) {
-    if (typeMapper === undefined) mapped.push(mapper.map(tp));
+    if (typeMapper === undefined) mapped.push(getMappedType(tp, mapper));
     else {
-      const t1 = typeMapper.map(tp);
-      mapped.push(t1 !== tp ? instantiateType(c, t1, mapper) : mapper.map(tp));
+      const t1 = getMappedType(tp, typeMapper);
+      mapped.push(t1 !== tp ? instantiateType(c, t1, mapper) : getMappedType(tp, mapper));
     }
   }
   const newAlias = alias ?? instantiateTypeAlias(c, type.alias, mapper);
@@ -804,10 +850,19 @@ export function instantiateSymbol(c: Checker, symbol: Symbol, mapper: TypeMapper
  * is resolved yet, so lazily instantiated members record it when tsgo would instantiate them.
  */
 export function keepsSymbolUnderInstantiation(c: Checker, symbol: Symbol, mapper: TypeMapper): boolean {
-  const symbolId = getSymbolId(symbol);
-  if (mapper.mapsThisOnly() && isThisless(symbol)) return true;
-  // A resolved type that can't change under instantiation keeps the symbol.
-  const type = c.symbolTypes.get(symbolId);
+  if (mapper.mapsThisOnly() && isThisless(symbol)) {
+    getSymbolId(symbol);
+    return true;
+  }
+  return keepsSymbolTypeUnderInstantiation(c, symbol);
+}
+
+/**
+ * Whether the resolved type of `symbol` (and its write type) can't change under instantiation, so that
+ * `instantiateSymbol` keeps it whatever the mapper. Once true, it stays true: types are resolved once.
+ */
+export function keepsSymbolTypeUnderInstantiation(c: Checker, symbol: Symbol): boolean {
+  const type = c.symbolTypes.get(getSymbolId(symbol));
   if (type !== undefined && !couldContainTypeVariables(c, type)) {
     if ((symbol.flags & SymbolFlags.SetAccessor) === 0) return true;
     const writeType = c.existingSymbolLinks(symbol)?.writeType;

package/src/compiler/jsdoc.ts

@@ -46,6 +46,7 @@ import {
   getTagName,
   getType,
   type EntityName,
+  getText,
 } from './ast.js';
 import { isReservedWord, tokenIsIdentifierOrKeyword } from './ast-utilities.js';
 import { CharacterCodes, isWhiteSpaceLike } from './character-codes.js';
@@ -937,6 +938,7 @@ export class JSDocParser {
         undefined,
         SyntaxKind.NamespaceKeyword,
         typeNameOrNamespaceName,
+        undefined,
         body,
       );
       if (nested) jsDocNamespaceNode.flags |= NodeFlags.NestedNamespace;
@@ -1270,7 +1272,7 @@ function textsEqual(a: Node, b: Node): boolean {
     if (
       a instanceof QualifiedName &&
       b instanceof QualifiedName &&
-      (a as QualifiedName).right.text === (b as QualifiedName).right.text
+      getText((a as QualifiedName).right) === getText((b as QualifiedName).right)
     ) {
       a = (a as QualifiedName).left;
       b = (b as QualifiedName).left;

package/src/compiler/link-tables.ts

@@ -7,8 +7,6 @@
 // checker that touches part of a program (as each of several parallel checkers does) stores only
 // the pages it touches.
 
-import type { Symbol } from './symbol.js';
-
 /** Links are stored in pages of 256 ids. */
 export const enum LinkPaging {
   Bits = 8,
@@ -203,20 +201,24 @@ const enum IdSetPaging {
 
 /** The number of set bits of a 32-bit value. */
 function bitCount(x: number): number {
-  x = x - ((x >>> 1) & 0x55555555);
+  x = (x - ((x >>> 1) & 0x55555555)) | 0;
   x = (x & 0x33333333) + ((x >>> 2) & 0x33333333);
   x = (x + (x >>> 4)) & 0x0f0f0f0f;
-  return Math.imul(x, 0x01010101) >>> 24;
+  // At most 32, so the top byte is the count with either shift; `>>` keeps it an int32.
+  return Math.imul(x, 0x01010101) >> 24;
 }
 
 /**
- * A page of a `CompactSymbolLinkTable`: one bit per id of the page in eight 32-id words, the number
- * of symbols stored before each word, and the symbols in id order. The words are fields, so a
- * lookup reads one object before the symbols. The class isn't generic, so natively the words are
- * 32-bit fields: every write stores an int32.
+ * A page of a `CompactLinkTable`'s presence bits: one bit per id of the page in eight 32-id words, the
+ * number of values stored before each word, and the position of the page's values in the table's
+ * `values`. The words are fields, so a lookup reads one object before the values. Natively the words
+ * are 32-bit fields, since every write stores an int32. A class that is generic or has a generic
+ * subclass keeps its number fields as doubles, so the values the bits index are in the table's
+ * `values`, not in this class or a subclass.
  */
 class CompactLinkPage {
-  readonly values: Symbol[];
+  /** The position of the page's values in the table's `values`. */
+  readonly position: number;
   private w0: number;
   private w1: number;
   private w2: number;
@@ -229,8 +231,8 @@ class CompactLinkPage {
   private before0: number;
   private before1: number;
 
-  constructor() {
-    this.values = [];
+  constructor(position: number) {
+    this.position = position | 0;
     this.w0 = 0;
     this.w1 = 0;
     this.w2 = 0;
@@ -297,72 +299,90 @@ class CompactLinkPage {
   rank(slot: number, bits: number): number {
     const word = slot >> 5;
     const before = ((word < 4 ? this.before0 : this.before1) >>> ((word & 3) << 3)) & 0xff;
-    return before + bitCount(bits & ((1 << (slot & 31)) - 1));
+    return (before + bitCount(bits & ((1 << (slot & 31)) - 1))) | 0;
   }
 
-  /** Adds `delta` to the counts of the words after `word`. */
+  /**
+   * Adds 1 (`delta` 1) or subtracts 1 (`delta` -1) from the counts of the words after `word`, a byte
+   * of `before0` or `before1` each. No byte carries or borrows: a count is at most 224, and a count
+   * that goes down includes the value removed.
+   */
   shiftCounts(word: number, delta: number): void {
-    for (let w = word + 1; w < 8; w++) {
-      const step = delta << ((w & 3) << 3);
-      if (w < 4) this.before0 = (this.before0 + step) | 0;
-      else this.before1 = (this.before1 + step) | 0;
-    }
+    // A 1 in each byte of the words after `word`: shifting `0x01010100` left by `word` bytes keeps
+    // the bytes above it, and shifts them all out at word 3.
+    const low = word < 4 ? 0x01010100 << (word << 3) : 0;
+    const high = word < 4 ? 0x01010101 : 0x01010100 << ((word & 3) << 3);
+    this.before0 = (this.before0 + Math.imul(low, delta)) | 0;
+    this.before1 = (this.before1 + Math.imul(high, delta)) | 0;
   }
 }
 
 /**
- * Symbols by node id, for ids a checker resolves in one in four to one in eight of the ids of the
- * pages it touches, as it resolves the identifiers and names of the files it checks. Pages of
- * `LinkPaging.Size` ids keep a presence bit per id and only the symbols stored, so a symbol costs
- * about one array slot. A `LinkTable` page costs a slot for every id, and a `Map` entry also
- * stores its key and a share of the hash buckets. At fewer values per page than that, the page's
- * own allocations outweigh what it saves, and a `SparseLinkTable` costs less.
+ * Values by node or symbol id, for ids a checker stores a value for in more than about one in
+ * sixteen of the ids of the pages it touches: the symbols it resolves for the identifiers and names
+ * of the files it checks (one in four to one in eight), the types and signatures it resolves for
+ * their type nodes and calls (one in twelve to one in seventeen), and the symbol columns most
+ * symbols leave empty, such as the name type of a property (one in ten to one in three with
+ * `--checkers 16`, where every checker touches symbols across the whole program). Pages of
+ * `LinkPaging.Size` ids keep a presence bit per id and only the values stored, so a value costs
+ * about one array slot. A `LinkTable` page costs a slot for every id, and a `Map` entry also stores
+ * its key and a share of the hash buckets. At fewer values per page than that, the page's own
+ * allocations outweigh what it saves, and a `SparseLinkTable` costs less.
  */
-export class CompactSymbolLinkTable {
+export class CompactLinkTable<T> {
+  /**
+   * The pages by `id >> LinkPaging.Bits`, up to the highest page stored; undefined where a page stores
+   * nothing. A checker stores values in a few percent of the pages of a large program, so the values
+   * are kept apart, one list for each page stored, rather than in a second slot per page.
+   */
   readonly pages: (CompactLinkPage | undefined)[] = [];
-  /** The number of symbols stored. */
+  /** The values of each page stored, in id order, at the page's `position`. */
+  readonly values: T[][] = [];
+  /** The number of values stored. */
   size = 0;
 
-  get(id: number): Symbol | undefined {
-    const page = this.pages[id >> LinkPaging.Bits];
+  get(id: number): T | undefined {
+    const index = id >> LinkPaging.Bits;
+    const page = this.pages[index];
     if (page === undefined) return undefined;
     const slot = id & LinkPaging.Mask;
     const bits = page.word(slot >> 5);
     if ((bits & (1 << (slot & 31))) === 0) return undefined;
-    return page.values[page.rank(slot, bits)];
+    return this.values[page.position]![page.rank(slot, bits)];
   }
 
-  set(id: number, value: Symbol | undefined): void {
+  set(id: number, value: T | undefined): void {
     const index = id >> LinkPaging.Bits;
     let page = this.pages[index];
     if (page === undefined) {
       if (value === undefined) return;
       while (this.pages.length <= index) this.pages.push(undefined);
-      page = new CompactLinkPage();
+      page = new CompactLinkPage(this.values.length);
       this.pages[index] = page;
+      this.values.push([]);
     }
+    const values = this.values[page.position]!;
     const slot = id & LinkPaging.Mask;
     const word = slot >> 5;
     const bit = 1 << (slot & 31);
     const bits = page.word(word);
     const at = page.rank(slot, bits);
-    const values = page.values;
     if ((bits & bit) !== 0) {
       if (value !== undefined) {
         values[at] = value;
         return;
       }
-      for (let i = at; i < values.length - 1; i++) values[i] = values[i + 1]!;
-      values.pop();
+      if (at === values.length - 1) values.pop();
+      else values.splice(at, 1);
       page.setWord(word, bits & ~bit);
       page.shiftCounts(word, -1);
       this.size--;
       return;
     }
     if (value === undefined) return;
-    values.push(value);
-    for (let i = values.length - 1; i > at; i--) values[i] = values[i - 1]!;
-    values[at] = value;
+    // Values are mostly stored in id order, at the end.
+    if (at === values.length) values.push(value);
+    else values.splice(at, 0, value);
     page.setWord(word, bits | bit);
     page.shiftCounts(word, 1);
     this.size++;
@@ -370,6 +390,31 @@ export class CompactSymbolLinkTable {
 
   clear(): void {
     this.pages.length = 0;
+    this.values.length = 0;
     this.size = 0;
   }
 }
+
+/**
+ * Int32 values by id, zero where none is stored, in a `CompactLinkTable`: pages of
+ * `LinkPaging.Size` ids keep a presence bit per id and only the nonzero values. For columns where a
+ * checker stores a value for fewer than about one in three of the ids of the pages it touches, such
+ * as the reference kinds of the symbols its files reference: an `IntLinkTable` page costs four bytes
+ * for every id.
+ */
+export class CompactIntLinkTable {
+  private readonly table = new CompactLinkTable<number>();
+
+  get(id: number): number {
+    return this.table.get(id) ?? 0;
+  }
+
+  set(id: number, value: number): void {
+    value = value | 0;
+    this.table.set(id, value === 0 ? undefined : value);
+  }
+
+  clear(): void {
+    this.table.clear();
+  }
+}