tsc-ts 0.0.5 → 0.0.6

package/src/compiler/transformers/declarations-syntactic.ts

@@ -89,7 +89,6 @@ import { combinePaths, getDirectoryPath, getNormalizedAbsolutePath, normalizePat
 import type { EmitContext } from '../printer/emit-context.js';
 import { EmitFlags } from '../printer/emit-flags.js';
 import { isIdentifierText } from '../scanner.js';
-import { Symbol, SymbolFlags, type SymbolTable, addDeclaration } from '../symbol.js';
 import { SyntaxKind } from '../syntax-kind.js';
 import { TokenFlags } from '../types.js';
 import type { SyntacticEmitResolver } from './emit-resolver.js';
@@ -126,6 +125,15 @@ import {
   typesOf,
   undefinedType,
 } from './declarations-pseudo.js';
+import {
+  addDeclaration,
+  declarationCount,
+  getDeclarations,
+  setDeclarations,
+  Symbol,
+  SymbolFlags,
+  type SymbolTable,
+} from '../symbol.js';
 
 const emptyTable: SymbolTable = new Map<string, Symbol>();
 
@@ -275,7 +283,7 @@ export class SyntacticDeclarationEmitResolver extends DeclarationEmitResolver {
     while (symbol !== undefined && !visited.has(symbol)) {
       visited.add(symbol);
       let next: Symbol | undefined = undefined;
-      for (const declaration of symbol.declarations) {
+      for (const declaration of getDeclarations(symbol)) {
         this.visibility.set(declaration, true);
         if (
           declaration instanceof ImportEqualsDeclaration &&
@@ -420,7 +428,7 @@ export class SyntacticDeclarationEmitResolver extends DeclarationEmitResolver {
     shouldComputeAliasesToMakeVisible: boolean,
   ): SymbolAccessibilityResult | undefined {
     const aliases: Node[] = [];
-    for (const declaration of symbol.declarations) {
+    for (const declaration of getDeclarations(symbol)) {
       if (declaration.kind === SyntaxKind.Identifier || this.isDeclarationVisible(declaration)) continue;
       let statement: Node | undefined = undefined;
       // Imports and unexported declarations can name types if their parent is visible.
@@ -505,7 +513,7 @@ export class SyntacticDeclarationEmitResolver extends DeclarationEmitResolver {
     const symbol = this.getSymbolOfDeclaration(node);
     if (symbol === undefined) return false;
     const signatures: Node[] = [];
-    const declarations = symbol.declarations;
+    const declarations = getDeclarations(symbol);
     for (let i = 0; i < declarations.length; i++) {
       const declaration = declarations[i]!;
       if (!isFunctionLike(declaration)) continue;
@@ -544,7 +552,7 @@ export class SyntacticDeclarationEmitResolver extends DeclarationEmitResolver {
       const symbol = this.resolveName(node, node.text, SymbolFlags.Value | SymbolFlags.ExportValue);
       if (symbol === undefined) return undefined;
       const resolved = symbol.exportSymbol ?? symbol;
-      return resolved.valueDeclaration ?? (resolved.declarations.length > 0 ? resolved.declarations[0]! : undefined);
+      return resolved.valueDeclaration ?? (declarationCount(resolved) > 0 ? resolved.declaration! : undefined);
     }
     if (!(node instanceof PropertyAccessExpression) || !(node.name instanceof Identifier)) return undefined;
     const name = node.name.text;
@@ -799,7 +807,7 @@ export class SyntacticDeclarationEmitResolver extends DeclarationEmitResolver {
 
   private hasMergedDeclarations(declaration: Node): boolean {
     const symbol = getSymbol(declaration);
-    return symbol !== undefined && this.pseudo.getMergedSymbol(symbol).declarations.length > symbol.declarations.length;
+    return symbol !== undefined && declarationCount(this.pseudo.getMergedSymbol(symbol)) > declarationCount(symbol);
   }
 
   /** Whether a parameter's pseudo-type already has `undefined`, so none is added. */
@@ -1404,7 +1412,7 @@ class PseudoTypeWriter {
 
 /** Parameters and type parameters are in scope where the signature's types are written. */
 function isSignatureLocal(symbol: Symbol): boolean {
-  const declaration = symbol.valueDeclaration ?? (symbol.declarations.length > 0 ? symbol.declarations[0] : undefined);
+  const declaration = symbol.valueDeclaration ?? (declarationCount(symbol) > 0 ? symbol.declaration : undefined);
   return (
     declaration !== undefined &&
     (declaration.kind === SyntaxKind.Parameter || declaration.kind === SyntaxKind.TypeParameter)
@@ -1779,7 +1787,7 @@ function mergeInto(target: Map<string, Symbol>, source: SymbolTable, mergedSymbo
     if (mergedSymbols.get(existing) !== existing) {
       // The first merge replaces the first file's symbol with a copy.
       merged = new Symbol(existing.flags, name);
-      merged.declarations = existing.declarations.slice();
+      setDeclarations(merged, getDeclarations(existing).slice());
       merged.valueDeclaration = existing.valueDeclaration;
       merged.exports = copyTable(existing.exports);
       merged.members = copyTable(existing.members);
@@ -1788,7 +1796,7 @@ function mergeInto(target: Map<string, Symbol>, source: SymbolTable, mergedSymbo
       target.set(name, merged);
     }
     merged.flags |= symbol.flags;
-    for (const declaration of symbol.declarations) addDeclaration(merged, declaration);
+    for (const declaration of getDeclarations(symbol)) addDeclaration(merged, declaration);
     merged.valueDeclaration ??= symbol.valueDeclaration;
     if (symbol.exports !== undefined) {
       merged.exports ??= new Map<string, Symbol>();

package/src/compiler/transformers/declarations-tracker.ts

@@ -3,7 +3,6 @@
 import { BinaryExpression, ExportAssignment, Identifier, type Node, type SourceFile, getExpression } from '../ast.js';
 import { getNameOfDeclaration, getSourceFileOfNode } from '../binder-utilities.js';
 import { type Diagnostic, type DiagnosticMessage, Diagnostics } from '../diagnostics.js';
-import { type Symbol, SymbolFlags } from '../symbol.js';
 import { SyntaxKind } from '../syntax-kind.js';
 import {
   DiagnosticContext,
@@ -20,6 +19,7 @@ import {
   type SymbolAccessibilityResult,
   SymbolTracker,
 } from './declarations-resolver.js';
+import { getDeclarations, type Symbol, SymbolFlags } from '../symbol.js';
 
 export class DeclarationTracker extends SymbolTracker {
   readonly resolver: DeclarationEmitResolver;
@@ -160,13 +160,13 @@ export class DeclarationTracker extends SymbolTracker {
 
   reportNonlocalAugmentation(containingFile: SourceFile, parentSymbol: Symbol, augmentingSymbol: Symbol): boolean {
     let primary: Node | undefined = undefined;
-    for (const declaration of parentSymbol.declarations)
+    for (const declaration of getDeclarations(parentSymbol))
       if (getSourceFileOfNode(declaration) === containingFile) {
         primary = declaration;
         break;
       }
     if (primary === undefined) return false;
-    for (const augmentation of augmentingSymbol.declarations) {
+    for (const augmentation of getDeclarations(augmentingSymbol)) {
       if (getSourceFileOfNode(augmentation) === containingFile) continue;
       const diagnostic = createDiagnosticForNode(
         augmentation,

package/src/compiler/transformers/declarations.ts

@@ -143,7 +143,6 @@ import {
   skipTrivia,
   stringToToken,
 } from '../scanner.js';
-import { SymbolFlags } from '../symbol.js';
 import type { CommentRange } from '../types.js';
 import { getRelativePathToDirectoryOrUrl } from '../sourcemap.js';
 import { SyntaxKind } from '../syntax-kind.js';
@@ -161,6 +160,7 @@ import { type DeclarationEmitResolver, NodeBuilderFlags } from './declarations-r
 import { ConstantKind } from './reference-resolver.js';
 import { DeclarationTracker } from './declarations-tracker.js';
 import { Transformer } from './transformer.js';
+import { declarationCount, getDeclarations, SymbolFlags } from '../symbol.js';
 
 export class DeclarationTransformer extends Transformer {
   readonly host: OutputPathsHost;
@@ -363,8 +363,8 @@ export class DeclarationTransformer extends Transformer {
     const symbol = file.symbol;
     const exportEquals =
       symbol === undefined || symbol.exports === undefined ? undefined : symbol.exports.get('export=');
-    if (exportEquals === undefined || exportEquals.declarations.length <= 1) return false;
-    for (const declaration of exportEquals.declarations)
+    if (exportEquals === undefined || declarationCount(exportEquals) <= 1) return false;
+    for (const declaration of getDeclarations(exportEquals))
       this.tracker.addDiagnostic(
         createDiagnosticForNode(
           declaration,
@@ -1037,7 +1037,7 @@ export class DeclarationTransformer extends Transformer {
   /** A private method is written as a property without a type. */
   private omitPrivateMethodType(input: Node): Node | undefined {
     const symbol = getSymbol(input);
-    if (symbol !== undefined && symbol.declarations.length > 0 && symbol.declarations[0] !== input) return undefined;
+    if (symbol !== undefined && declarationCount(symbol) > 0 && symbol.declaration !== input) return undefined;
     const result = this.factory.created(
       new PropertyDeclaration(this.ensureModifiers(input), getName(input)!, undefined, undefined, undefined),
     );
@@ -3003,7 +3003,7 @@ function getFullSignature(node: Node): Node | undefined {
 function isCommonJSAliasExport(node: Node): boolean {
   if (!(node instanceof BinaryExpression) || !(node.right instanceof Identifier)) return false;
   const symbol = node.symbol;
-  return symbol !== undefined && symbol.declarations.length === 1;
+  return symbol !== undefined && declarationCount(symbol) === 1;
 }
 
 function getLeftmostAccessExpression(node: Node): Node {
@@ -3018,7 +3018,7 @@ function shouldEmitFunctionProperties(fn: FunctionDeclaration): boolean {
   if (fn.body !== undefined) return true;
   const symbol = fn.symbol;
   if (symbol === undefined) return false;
-  for (const declaration of symbol.declarations)
+  for (const declaration of getDeclarations(symbol))
     if (declaration instanceof FunctionDeclaration && declaration.body !== undefined) return true;
   return false;
 }

package/src/compiler/transformers/reference-resolver.ts

@@ -48,13 +48,24 @@ import {
   isEnumConst,
   isExternalOrCommonJSModule,
 } from '../binder-utilities.js';
+import { IntLinkTable, LinkTable } from '../link-tables.js';
 import { NameResolver } from '../name-resolver.js';
 import { isSameNode } from './utilities.js';
 import { pathIsRelative } from '../path.js';
 import { type CompilerOptions, shouldPreserveConstEnums } from '../options.js';
-import { InternalSymbolName, Symbol, SymbolFlags, type SymbolTable, addDeclaration } from '../symbol.js';
 import { SyntaxKind } from '../syntax-kind.js';
 import { TokenFlags } from '../types.js';
+import {
+  addDeclaration,
+  declarationAt,
+  declarationCount,
+  getDeclarations,
+  InternalSymbolName,
+  setDeclarations,
+  Symbol,
+  SymbolFlags,
+  type SymbolTable,
+} from '../symbol.js';
 
 export const enum ConstantKind {
   None,
@@ -210,7 +221,7 @@ export class MergedGlobals {
       )
         return source;
       result = new Symbol(resolved.flags | SymbolFlags.Transient, resolved.name);
-      result.declarations = resolved.declarations.slice();
+      setDeclarations(result, getDeclarations(resolved).slice());
       result.parent = resolved.parent;
       result.valueDeclaration = resolved.valueDeclaration;
       result.members = resolved.members === undefined ? undefined : new Map<string, Symbol>(resolved.members);
@@ -228,7 +239,7 @@ export class MergedGlobals {
     if ((result.flags & SymbolFlags.ConstEnumOnlyModule) === 0) sourceFlags &= ~SymbolFlags.ConstEnumOnlyModule;
     result.flags |= sourceFlags;
     if (source.valueDeclaration !== undefined) setValueDeclaration(result, source.valueDeclaration);
-    for (let i = 0; i < source.declarations.length; i++) addDeclaration(result, source.declarations[i]!);
+    for (let i = 0; i < declarationCount(source); i++) addDeclaration(result, declarationAt(source, i));
     if (source.members !== undefined) {
       if (result.members === undefined) result.members = new Map<string, Symbol>();
       this.mergeTable(result.members, source.members, undefined);
@@ -316,9 +327,10 @@ export class ReferenceResolver {
   private readonly enumValues: Map<Node, Evaluation>;
   private readonly computedEnums: Set<Node>;
   private readonly aliasTargets: Map<Symbol, Symbol>;
-  /** Value symbols of identifiers resolved as expressions, as the checker caches them. */
-  private readonly resolvedSymbols: Map<Node, Symbol>;
-  private readonly unresolvedReferences: Set<Node>;
+  /** Value symbols of identifiers resolved as expressions, as the checker caches them, by node id. */
+  private readonly resolvedSymbols: LinkTable<Symbol>;
+  /** 1 for each identifier, by node id, that resolved to no value symbol. */
+  private readonly unresolvedReferences: IntLinkTable;
   private readonly unresolvedAliases: Set<Symbol>;
   private readonly resolvingAliases: Set<Symbol>;
   /** The module each module specifier names (`null` for none), by specifier. */
@@ -340,8 +352,8 @@ export class ReferenceResolver {
     this.enumValues = new Map<Node, Evaluation>();
     this.computedEnums = new Set<Node>();
     this.aliasTargets = new Map<Symbol, Symbol>();
-    this.resolvedSymbols = new Map<Node, Symbol>();
-    this.unresolvedReferences = new Set<Node>();
+    this.resolvedSymbols = new LinkTable<Symbol>();
+    this.unresolvedReferences = new IntLinkTable();
     this.unresolvedAliases = new Set<Symbol>();
     this.resolvingAliases = new Set<Symbol>();
     this.specifierModules = new Map<Node, Symbol | null>();
@@ -364,20 +376,20 @@ export class ReferenceResolver {
 
   /** The value an identifier in an expression refers to, cached for later queries of the identifier. */
   getResolvedSymbol(node: Identifier): Symbol | undefined {
-    const cached = this.resolvedSymbols.get(node as Node);
+    const cached = this.resolvedSymbols.get(node.id);
     if (cached !== undefined) return cached;
-    if (this.unresolvedReferences.has(node as Node)) return undefined;
+    if (this.unresolvedReferences.get(node.id) !== 0) return undefined;
     const symbol = this.resolveName(node, node.text, SymbolFlags.Value | SymbolFlags.ExportValue);
-    if (symbol === undefined) this.unresolvedReferences.add(node as Node);
-    else this.resolvedSymbols.set(node as Node, symbol);
+    if (symbol === undefined) this.unresolvedReferences.set(node.id, 1);
+    else this.resolvedSymbols.set(node.id, symbol);
     return symbol;
   }
 
   private getReferencedValueSymbol(reference: Identifier, startInDeclarationContainer: boolean): Symbol | undefined {
     // An identifier resolved as an expression keeps that meaning, as with the checker's cache.
-    const cached = this.resolvedSymbols.get(reference as Node);
+    const cached = this.resolvedSymbols.get(reference.id);
     if (cached !== undefined) return cached;
-    if (this.unresolvedReferences.has(reference as Node)) return undefined;
+    if (this.unresolvedReferences.get(reference.id) !== 0) return undefined;
     let location: Node = reference;
     const parent = reference.parent;
     if (startInDeclarationContainer && parent !== undefined && isSameNode(getName(parent), reference)) {
@@ -443,7 +455,7 @@ export class ReferenceResolver {
   getReferencedImportDeclaration(node: Identifier): Node | undefined {
     // As the checker: an identifier that didn't resolve as a value may still name an alias.
     const reference: Node = node;
-    let symbol = this.resolvedSymbols.get(reference);
+    let symbol = this.resolvedSymbols.get(reference.id);
     if (symbol === undefined) symbol = this.resolveName(node, node.text, valueMeaning);
     if (
       symbol === undefined ||
@@ -477,7 +489,7 @@ export class ReferenceResolver {
     if (resolved === undefined) return undefined;
     const symbol = this.getExportSymbolOfValueSymbolIfExported(resolved);
     const declarations: Node[] = [];
-    for (const declaration of symbol.declarations)
+    for (const declaration of getDeclarations(symbol))
       if (isValueDeclarationKind(declaration.kind)) declarations.push(declaration);
     return declarations;
   }
@@ -526,7 +538,7 @@ export class ReferenceResolver {
     if (exports === undefined || exports.has(name) || name === InternalSymbolName.Default) return false;
     const star = exports.get(InternalSymbolName.ExportStar);
     if (star === undefined) return false;
-    for (const declaration of star.declarations) {
+    for (const declaration of getDeclarations(star)) {
       if (!(declaration instanceof ExportDeclaration)) continue;
       const target = this.resolveExternalModuleSymbol(
         this.resolveModuleSpecifier(declaration, declaration.moduleSpecifier),
@@ -539,8 +551,8 @@ export class ReferenceResolver {
 
   /** Whether a symbol is declared in the global scope. */
   isGlobalSymbol(symbol: Symbol): boolean {
-    if (symbol.declarations.length === 0) return false;
-    const container = getDeclarationContainer(symbol.declarations[0]!);
+    if (declarationCount(symbol) === 0) return false;
+    const container = getDeclarationContainer(symbol.declaration!);
     return container instanceof SourceFile && !isExternalOrCommonJSModule(container as SourceFile);
   }
 
@@ -746,7 +758,7 @@ export class ReferenceResolver {
     if (name === InternalSymbolName.Default) return undefined;
     const star = exports.get(InternalSymbolName.ExportStar);
     if (star === undefined) return undefined;
-    for (const declaration of star.declarations) {
+    for (const declaration of getDeclarations(star)) {
       if (!(declaration instanceof ExportDeclaration)) continue;
       const target = this.resolveExternalModuleSymbol(
         this.resolveModuleSpecifier(declaration, declaration.moduleSpecifier),
@@ -926,7 +938,7 @@ export class ReferenceResolver {
     if (symbol === undefined) return noEvaluation;
     if (expression instanceof Identifier && (expression.text === 'Infinity' || expression.text === 'NaN')) {
       // A global `Infinity` or `NaN`; without lib files these don't resolve at all.
-      if (symbol.declarations.length > 0 && isAmbientGlobal(symbol))
+      if (declarationCount(symbol) > 0 && isAmbientGlobal(symbol))
         return numberEvaluation(expression.text === 'NaN' ? NaN : Infinity);
     }
     if ((symbol.flags & SymbolFlags.EnumMember) !== 0) return this.evaluateEnumMemberSymbol(symbol, location);
@@ -1029,8 +1041,8 @@ export function isEntityNameExpressionNode(node: Node): boolean {
 }
 
 function isAmbientGlobal(symbol: Symbol): boolean {
-  for (let i = 0; i < symbol.declarations.length; i++)
-    if ((symbol.declarations[i].flags & NodeFlags.Ambient) === 0) return false;
+  for (let i = 0; i < declarationCount(symbol); i++)
+    if ((declarationAt(symbol, i).flags & NodeFlags.Ambient) === 0) return false;
   return true;
 }
 
@@ -1112,8 +1124,8 @@ function isAliasSymbolDeclaration(node: Node): boolean {
 }
 
 export function getDeclarationOfAliasSymbol(symbol: Symbol): Node | undefined {
-  for (let i = symbol.declarations.length - 1; i >= 0; i--) {
-    const declaration = symbol.declarations[i]!;
+  for (let i = declarationCount(symbol) - 1; i >= 0; i--) {
+    const declaration = declarationAt(symbol, i);
     if (isAliasSymbolDeclaration(declaration)) return declaration;
   }
   return undefined;

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

@@ -33,6 +33,7 @@ import {
   HeritageClause,
   getModifiers,
 } from '../ast.js';
+import { ClusteredIntLinkTable } from '../link-tables.js';
 import { isTypeNodeKind } from '../printer/utilities.js';
 import { SyntaxKind } from '../syntax-kind.js';
 
@@ -43,20 +44,27 @@ const enum Facts {
   Final = 2,
 }
 
+/** The answers `TypeScriptFacts.cache` stores; zero is unknown. */
+const enum Answer {
+  No = 1,
+  Yes = 2,
+}
+
 /** Memoized `containsTypeScript` answers for one emit. */
 export class TypeScriptFacts extends NodeVisitor {
-  private readonly cache: Map<Node, boolean>;
+  /** The answer for each node, by node id. */
+  private readonly cache: ClusteredIntLinkTable;
   private found: boolean;
 
   constructor() {
     super();
-    this.cache = new Map<Node, boolean>();
+    this.cache = new ClusteredIntLinkTable();
     this.found = false;
   }
 
   containsTypeScript(node: Node): boolean {
-    const cached = this.cache.get(node);
-    if (cached !== undefined) return cached;
+    const cached = this.cache.get(node.id);
+    if (cached !== 0) return cached === Answer.Yes;
     const own = ownFacts(node);
     let result = (own & Facts.TypeScript) !== 0;
     if (!result && (own & Facts.Final) === 0) {
@@ -66,7 +74,7 @@ export class TypeScriptFacts extends NodeVisitor {
       result = this.found;
       this.found = saved;
     }
-    this.cache.set(node, result);
+    this.cache.set(node.id, result ? Answer.Yes : Answer.No);
     return result;
   }
 

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

@@ -26,6 +26,7 @@ import {
   getModifiers,
   getName,
 } from '../ast.js';
+import { ClusteredIntLinkTable } from '../link-tables.js';
 import { isTypeNodeKind } from '../printer/utilities.js';
 import { SyntaxKind } from '../syntax-kind.js';
 import { TokenFlags } from '../types.js';
@@ -75,22 +76,26 @@ const enum Exclusions {
   BindingPattern = SubtreeFacts.ContainsRestOrSpread,
 }
 
+/** Marks a computed entry of `SyntaxFacts.cache`, whose facts may be `None`. */
+const computedFacts = 1 << 30;
+
 /** Memoized subtree facts for one emit; synthesized nodes get theirs on first use. */
 export class SyntaxFacts extends NodeVisitor {
-  private readonly cache: Map<Node, SubtreeFacts>;
+  /** The facts of each node, by node id, with `computedFacts` set. */
+  private readonly cache: ClusteredIntLinkTable;
   private collected: SubtreeFacts;
 
   constructor() {
     super();
-    this.cache = new Map<Node, SubtreeFacts>();
+    this.cache = new ClusteredIntLinkTable();
     this.collected = SubtreeFacts.None;
   }
 
   of(node: Node): SubtreeFacts {
-    const cached = this.cache.get(node);
-    if (cached !== undefined) return cached;
+    const cached = this.cache.get(node.id);
+    if (cached !== 0) return cached & ~computedFacts;
     const facts = this.compute(node);
-    this.cache.set(node, facts);
+    this.cache.set(node.id, facts | computedFacts);
     return facts;
   }
 

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

@@ -24,9 +24,9 @@ import {
   getIsTypeOnly,
 } from '../ast.js';
 import { getStrictOptionValue } from '../options.js';
-import { Symbol, SymbolFlags } from '../symbol.js';
 import { SyntaxKind } from '../syntax-kind.js';
 import { ConstantKind, type ReferenceResolver } from './reference-resolver.js';
+import { declarationAt, declarationCount, getDeclarations, Symbol, SymbolFlags } from '../symbol.js';
 
 /** What a type reference in decorator metadata serializes to. */
 export const enum TypeReferenceSerializationKind {
@@ -62,9 +62,9 @@ export function getTypeReferenceSerializationKind(
   let isTypeOnly = false;
   if (typeName instanceof QualifiedName) {
     const root = resolveEntityName(resolver, getFirstIdentifier(typeName), SymbolFlags.Value, true, location);
-    if (root !== undefined && root !== unknownSymbol && root.declarations.length > 0) {
+    if (root !== undefined && root !== unknownSymbol && declarationCount(root) > 0) {
       isTypeOnly = true;
-      for (const declaration of root.declarations)
+      for (const declaration of getDeclarations(root))
         if (!isTypeOnlyImportOrExportDeclaration(declaration)) {
           isTypeOnly = false;
           break;
@@ -155,8 +155,8 @@ function hasConstructSignature(resolver: ReferenceResolver, type: Node, location
   if (type instanceof TypeReferenceNode) {
     const symbol = resolveEntityName(resolver, type.typeName, SymbolFlags.Type, false, location);
     if (symbol === undefined || symbol === unknownSymbol) return false;
-    for (let i = 0; i < symbol.declarations.length; i++) {
-      const declaration = symbol.declarations[i]!;
+    for (let i = 0; i < declarationCount(symbol); i++) {
+      const declaration = declarationAt(symbol, i);
       if (
         declaration instanceof InterfaceDeclaration &&
         hasMember(declaration.members.nodes, SyntaxKind.ConstructSignature)
@@ -196,22 +196,22 @@ class TypeClassifier {
     }
     if ((flags & SymbolFlags.Class) !== 0) return TypeReferenceSerializationKind.ObjectType;
     if ((flags & SymbolFlags.TypeAlias) !== 0) {
-      for (let i = 0; i < symbol.declarations.length; i++) {
-        const declaration = symbol.declarations[i]!;
+      for (let i = 0; i < declarationCount(symbol); i++) {
+        const declaration = declarationAt(symbol, i);
         if (declaration instanceof TypeAliasDeclaration)
           return this.ofTypeNode(declaration.type, declaration, depth + 1);
       }
       return TypeReferenceSerializationKind.ObjectType;
     }
     if ((flags & SymbolFlags.TypeParameter) !== 0) {
-      const declaration = symbol.declarations.length > 0 ? symbol.declarations[0]! : undefined;
+      const declaration = declarationCount(symbol) > 0 ? symbol.declaration! : undefined;
       if (declaration instanceof TypeParameterDeclaration && declaration.constraint !== undefined)
         return this.ofTypeNode(declaration.constraint, declaration, depth + 1);
       return TypeReferenceSerializationKind.ObjectType;
     }
     if ((flags & SymbolFlags.Interface) !== 0) {
-      for (let i = 0; i < symbol.declarations.length; i++) {
-        const declaration = symbol.declarations[i]!;
+      for (let i = 0; i < declarationCount(symbol); i++) {
+        const declaration = declarationAt(symbol, i);
         if (
           declaration instanceof InterfaceDeclaration &&
           hasMember(declaration.members.nodes, SyntaxKind.CallSignature)
@@ -226,8 +226,8 @@ class TypeClassifier {
   private ofEnum(symbol: Symbol): TypeReferenceSerializationKind {
     let strings = false;
     let numbers = false;
-    for (let i = 0; i < symbol.declarations.length; i++) {
-      const declaration = symbol.declarations[i]!;
+    for (let i = 0; i < declarationCount(symbol); i++) {
+      const declaration = declarationAt(symbol, i);
       if (!(declaration instanceof EnumDeclaration)) continue;
       const members = declaration.members.nodes;
       for (let j = 0; j < members.length; j++) {

package/src/compiler/tsc-build.ts

@@ -721,16 +721,13 @@ export class Orchestrator {
     const host = new BuildCompilerHost(sys, this.fs, this.locale);
     const configOptions = config.options;
     const checkers = threads ? checkerThreads(configOptions.checkers, configOptions.singleThreaded) : 1;
-    if (checkers > 1 && parallelParse.spawn !== undefined) {
+    if (threads && configOptions.singleThreaded !== true && parallelParse.spawn !== undefined) {
       // Threads parse and bind the program's files ahead of it (parallel-parse.ts), as for plain
-      // compiles that check on threads. Here also when the program is checked on this thread, as
-      // after a change with old build info, whose program is parsed in full all the same. The
-      // program's FileLoader takes the files they prepared, and resolves their imports and
-      // references itself (`takesPreparedResolutions`): the build info lists the `package.json`
-      // files the program's module resolution looked up, and which ones it looks up depends on the
-      // order of its resolutions and on what its own caches hold. Declaration files that earlier
-      // projects of the build parsed come from the build's cache, and parse threads don't load
-      // them again.
+      // compiles. Here also when the program is checked on this thread, with one checker or after a
+      // change with old build info, whose program is parsed in full all the same. The
+      // program's FileLoader takes the files they prepared and the resolutions found loading them.
+      // Declaration files that earlier projects of the build parsed come from the build's cache,
+      // and parse threads don't load them again.
       const libraryDirectory = getNormalizedAbsolutePath(sys.defaultLibraryPath, sys.currentDirectory);
       const session = new ParseSession(
         parseThreads(checkers),
@@ -742,9 +739,15 @@ export class Orchestrator {
           buildSourceFileNames.has(kind === LoadKind.Library ? combinePaths(libraryDirectory, name) : name),
       );
       session.start(config.fileNames, () => {
-        const loader = new FileLoader(host, config);
-        loader.takesPreparedResolutions = false;
-        const program = new Program(config, host, loader);
+        // The program takes the resolutions the threads found, as `tsc -p` does, and is loaded
+        // again resolving every file itself only where their `package.json` lookups may miss some
+        // of its own (`hasAllPackageJsonLookups`), which the build info lists.
+        let program = new Program(config, host, new FileLoader(host, config));
+        if (!program.hasAllPackageJsonLookups()) {
+          const loader = new FileLoader(host, config);
+          loader.takesPreparedResolutions = false;
+          program = new Program(config, host, loader);
+        }
         reportPreparedFiles(program.getSourceFiles().map((f) => f.fileName));
         if (!this.checkAndEmit(task, program, parseStart, times, oldSnapshot, mayUseThreads, then)) then();
       });
@@ -824,7 +827,7 @@ export class Orchestrator {
       this.emitAndReport(task, checked, times, oldSnapshot, undefined, incrementalProgram);
       return false;
     }
-    const files = incrementalProgram.filesToCheck();
+    const files = incrementalProgram.filesForCheckers();
     if (!rechecksOnThreads(files, count, options.checkers !== undefined)) {
       this.emitAndReport(task, checked, times, oldSnapshot, undefined, incrementalProgram);
       return false;
@@ -839,6 +842,7 @@ export class Orchestrator {
       },
       true,
       incrementalProgram.emitKindsOnCheckers(files),
+      incrementalProgram.checksOnCheckers,
     );
     return true;
   }

package/src/compiler/tsc-cli.ts

@@ -18,7 +18,7 @@ import {
   type Locale,
   type MessageWithArgs,
 } from './diagnostics.js';
-import { CompilerHost, FileLoader } from './file-loader.js';
+import { CompilerHost, FileLoader, releaseLater } from './file-loader.js';
 import { CachedFileSystem, FileSystem, type DirectoryEntries } from './file-system.js';
 import { Program, sortAndDeduplicateDiagnostics } from './program.js';
 import { ConfigParser, ParsedCommandLine as ProjectConfig } from './tsconfig.js';
@@ -437,7 +437,7 @@ function executeCompile(sys: System, commandLine: ParsedCommandLine): CommandLin
             config.fileNames.length > 0,
           );
         // While the threads load files, the program's first step (a task per root file, which looks
-        // the file up) runs, and the tasks of the files they return are built ahead.
+        // the file up) runs, and the program's loader takes the files they return as they come.
         const host = new SystemCompilerHost(sys, fs, locale);
         const loader = new FileLoader(host, config);
         let rootFilesAdded = false;
@@ -447,7 +447,7 @@ function executeCompile(sys: System, commandLine: ParsedCommandLine): CommandLin
         const resolvesPackageJsons = config.configName !== '' && config.buildInfoFileName() !== '';
         session.onIdle = (batch) => {
           if (!rootFilesAdded) rootFilesAdded = loader.addRootFiles(rootFilesPerChunk);
-          loader.takeAhead(batch.files);
+          loader.walkAhead(batch.files);
           if (resolvesPackageJsons) {
             const lookups = batch.packageJsons;
             for (let k = 0; k < lookups.directories.length; k++)
@@ -471,6 +471,8 @@ function executeCompile(sys: System, commandLine: ParsedCommandLine): CommandLin
             result = createProgram(host, own);
           }
           done(result);
+          // The session's callbacks keep the loader: its tasks go once checking has started.
+          releaseLater(loader);
         });
         // The build info of an incremental program is read while the threads parse: reading it needs
         // only the config (compile and recheckInParallel, tsc-compile.ts, take it from here).
@@ -504,11 +506,12 @@ export const rootFilesPerChunk = 32;
 
 /**
  * Whether threads parse and bind the files of a program with `options` ahead of it (parallel-parse.ts):
- * where checker threads may be used. Also for an incremental program with build info, which is checked
- * on this thread (`checksIncrementalOnThreads`) but parsed in full all the same, as in build mode.
+ * unless `--singleThreaded` is given, as tsgo parses on every core whatever its checker count. Also with
+ * one checker, which checks on this thread, and for an incremental program with build info, whose
+ * program is parsed in full all the same, as in build mode.
  */
 function parsesAhead(options: CompilerOptions): boolean {
-  return checkerThreads(options.checkers, options.singleThreaded) > 1 && parallelParse.spawn !== undefined;
+  return options.singleThreaded !== true && parallelParse.spawn !== undefined;
 }
 
 /**