tsc-ts 0.0.7 → 0.0.9

package/README.md

@@ -31,7 +31,7 @@ npx tsc-ts -p tsconfig.json
 npx tsc-ts --noEmit src/index.ts
 ```
 
-`tsc-ts --api` serves the TypeScript API over stdin and stdout, like `tsc --api`.
+`tsc-ts --api` serves the TypeScript API over stdin and stdout, like `tsc --api`. On Windows, `--api --pipe \\.\pipe\<name>` serves it over a named pipe it creates, as `tsc --api --pipe` does, for clients that connect to the pipe (such as scriptc under Node.js); only the native executable supports `--pipe`.
 
 `--checkers N` checks the program on N threads. Unless `--checkers` or `--singleThreaded` is given, the native executable uses one checker per CPU it may run on (up to 16), and at least tsgo's four; it uses fewer than the CPUs, but never fewer than four, when the estimated peak memory of more checkers would not fit 85% of the machine's memory (`TSC_TS_CHECKERS=fixed` keeps tsgo's four), and checkers beyond the fourth stop taking files, one at a time, when the process's memory reaches that share; it shares one program between its threads and also parses and binds the program's files on them. Unless `--singleThreaded` is given, the program's files are parsed and bound on threads also with `--checkers 1`, as tsgo does. Files that share costly declarations, such as a large generated schema and the few files importing it, are checked together on one checker. Under Node.js, where every thread builds its own copy of the program, tsc-ts checks on one thread unless `--checkers` is given. `--incremental`, `--watch` and `--build` always check on one thread. The diagnostics are the same as with one checker.
 

package/dist/api/compiler/checker-declaration-order.js

@@ -12,7 +12,7 @@ import { getExportSymbolOfValueSymbolIfExported } from './checker-symbols.js';
 import { getBaseTypes, getDeclaredTypeOfSymbol } from './checker-declared-types.js';
 import { getPropertyOfType } from './checker-members.js';
 import { getFunctionFlags } from './checker-utilities.js';
-import { getDeclarations } from './symbol.js';
+import { declarationAt, declarationCount } from './symbol.js';
 /** Reports a block-scoped variable, class or enum resolved at `errorLocation` before its declaration. */
 export function checkResolvedBlockScopedVariable(c, resolved, errorLocation) {
     const result = getExportSymbolOfValueSymbolIfExported(c, resolved);
@@ -23,7 +23,8 @@ export function checkResolvedBlockScopedVariable(c, resolved, errorLocation) {
         (result.flags & 32 /* SymbolFlags.Class */) !== 0)
         return;
     let declaration;
-    for (const d of getDeclarations(result)) {
+    for (let i = 0; i < declarationCount(result); i++) {
+        const d = declarationAt(result, i);
         if (isBlockOrCatchScoped(d) || isClassLike(d) || d.kind === 267 /* SyntaxKind.EnumDeclaration */) {
             declaration = d;
             break;

package/dist/api/compiler/checker-declared-types.js

@@ -20,7 +20,7 @@ import { getIndexedAccessType, isGenericMappedType } from './checker-type-operat
 import { getSignatureInstantiation } from './checker-signatures.js';
 import { evaluateEnumMember } from './checker-evaluator.js';
 import { checkTypeAssignableTo, isTypeIdenticalTo } from './relations.js';
-import { getDeclarations } from './symbol.js';
+import { declarationAt, declarationCount, getDeclarations } from './symbol.js';
 export { getParentOfSymbol };
 export function getDeclaredTypeOfSymbol(c, symbol) {
     return tryGetDeclaredTypeOfSymbol(c, symbol) ?? c.errorType;
@@ -752,11 +752,14 @@ export function getMinTypeArgumentCount(c, typeParameters) {
 }
 /** Whether a type parameter is declared with a default, without resolving it. */
 function hasTypeParameterDefault(t) {
-    if (t.symbol === undefined)
+    const symbol = t.symbol;
+    if (symbol === undefined)
         return false;
-    for (const d of getDeclarations(t.symbol))
+    for (let i = 0; i < declarationCount(symbol); i++) {
+        const d = declarationAt(symbol, i);
         if (d.kind === 169 /* SyntaxKind.TypeParameter */ && d.defaultType !== undefined)
             return true;
+    }
     return false;
 }
 export function fillMissingTypeArguments(c, typeArguments, typeParameters, minTypeArgumentCount, isJavaScriptImplicitAny) {

package/dist/api/compiler/checker-deprecation.js

@@ -12,7 +12,7 @@ import { entityNameToString } from './checker-expressions.js';
 import { isErrorType } from './checker-type-factory.js';
 import { getPropertyOfType } from './checker-members.js';
 import { signatureToString } from './type-printer.js';
-import { declarationCount, getDeclarations } from './symbol.js';
+import { declarationAt, declarationCount, getDeclarations } from './symbol.js';
 /** Whether `declaration`, or the statement it belongs to, has a `@deprecated` JSDoc tag. */
 export function isDeprecatedDeclaration(declaration) {
     if ((getCombinedNodeFlags(declaration) & 67108864 /* NodeFlags.PossiblyContainsDeprecatedTag */) === 0)
@@ -38,24 +38,24 @@ function getJSDocDeprecatedTag(node) {
  * members when all are.
  */
 export function isDeprecatedSymbol(c, symbol) {
-    const declarations = getDeclarations(symbol);
+    const count = declarationCount(symbol);
     const parentSymbol = getParentOfSymbol(c, symbol);
-    if (parentSymbol !== undefined && declarations.length > 1)
+    if (parentSymbol !== undefined && count > 1)
         return (parentSymbol.flags & 64 /* SymbolFlags.Interface */) !== 0
-            ? someDeprecatedDeclaration(declarations)
-            : everyDeprecatedDeclaration(declarations);
+            ? someDeprecatedDeclaration(symbol)
+            : everyDeprecatedDeclaration(symbol);
     return ((symbol.valueDeclaration !== undefined && isDeprecatedDeclaration(symbol.valueDeclaration)) ||
-        (declarations.length !== 0 && everyDeprecatedDeclaration(declarations)));
+        (count !== 0 && everyDeprecatedDeclaration(symbol)));
 }
-function someDeprecatedDeclaration(declarations) {
-    for (const d of declarations)
-        if (isDeprecatedDeclaration(d))
+function someDeprecatedDeclaration(symbol) {
+    for (let i = 0; i < declarationCount(symbol); i++)
+        if (isDeprecatedDeclaration(declarationAt(symbol, i)))
             return true;
     return false;
 }
-function everyDeprecatedDeclaration(declarations) {
-    for (const d of declarations)
-        if (!isDeprecatedDeclaration(d))
+function everyDeprecatedDeclaration(symbol) {
+    for (let i = 0; i < declarationCount(symbol); i++)
+        if (!isDeprecatedDeclaration(declarationAt(symbol, i)))
             return false;
     return true;
 }
@@ -290,7 +290,8 @@ export function checkDeprecatedTypeReference(c, node, type) {
     const symbol = c.resolvedSymbols.get(node.id);
     if (symbol === undefined)
         return;
-    for (const d of getDeclarations(symbol)) {
+    for (let i = 0; i < declarationCount(symbol); i++) {
+        const d = declarationAt(symbol, i);
         if (isTypeDeclaration(d) && isDeprecatedDeclaration(d)) {
             addDeprecatedSuggestion(c, getDeprecatedSuggestionNode(node), getDeclarations(symbol), symbol.name);
             return;

package/dist/api/compiler/checker-destructuring.js

@@ -22,7 +22,7 @@ import { getNonNullableType, getTypeWithFacts, hasTypeFacts } from './checker-fl
 import { sliceTupleType } from './checker-signatures.js';
 import { getPropertyNameFromType, isTypeUsableAsPropertyName, maybeTypeOfKind } from './checker-utilities.js';
 import { checkPropertyAccessibility } from './checker-property-access.js';
-import { copyDeclarations, getDeclarations, getSymbolId } from './symbol.js';
+import { copyDeclarations, declarationAt, declarationCount, getSymbolId, } from './symbol.js';
 function isBindingPatternNode(node) {
     return (node !== undefined &&
         (node.kind === 207 /* SyntaxKind.ObjectBindingPattern */ || node.kind === 208 /* SyntaxKind.ArrayBindingPattern */));
@@ -548,7 +548,8 @@ export function isSpreadableProperty(prop) {
     const notMethodOrAccessor = (prop.flags & (8192 /* SymbolFlags.Method */ | 32768 /* SymbolFlags.GetAccessor */ | 65536 /* SymbolFlags.SetAccessor */)) === 0;
     let hasPrivateName = false;
     let inClass = false;
-    for (const d of getDeclarations(prop)) {
+    for (let i = 0; i < declarationCount(prop); i++) {
+        const d = declarationAt(prop, i);
         if (isPrivateIdentifierClassElementDeclaration(d))
             hasPrivateName = true;
         if (d.parent !== undefined && isClassLike(d.parent))

package/dist/api/compiler/checker-members.js

@@ -702,8 +702,12 @@ export function resolveDeclaredMembers(c, t) {
         const members = getMembersOfSymbol(c, t.symbol);
         declared.declaredMembersResolved = true;
         declared.declaredMembers = members;
-        declared.declaredCallSignatures = getSignaturesOfSymbol(c, members.get("\uFFFEcall" /* InternalSymbolName.Call */));
-        declared.declaredConstructSignatures = getSignaturesOfSymbol(c, members.get("\uFFFEnew" /* InternalSymbolName.New */));
+        // Most interfaces declare neither, and share one empty list.
+        const call = members.get("\uFFFEcall" /* InternalSymbolName.Call */);
+        const construct = members.get("\uFFFEnew" /* InternalSymbolName.New */);
+        declared.declaredCallSignatures = call !== undefined ? getSignaturesOfSymbol(c, call) : emptySignatures;
+        declared.declaredConstructSignatures =
+            construct !== undefined ? getSignaturesOfSymbol(c, construct) : emptySignatures;
         declared.declaredIndexInfos = getIndexInfosOfSymbol(c, t.symbol);
     }
     return declared;

package/dist/api/compiler/checker-source-file.d.ts

@@ -5,6 +5,18 @@ import type { Checker } from './checker.js';
  * identifiers, which need the whole file checked first.
  */
 export declare function checkSourceFile(c: Checker, file: SourceFile, checkUnused?: boolean): void;
+/**
+ * Checks the statements `start` to `end` of the declaration file `file`, one of the ranges that several
+ * checkers check it in (parallel-check.ts), and returns whether the checker then has diagnostics in the
+ * file. The range ending the file also runs the checks of the whole file. The file is not marked checked.
+ *
+ * When no range finds a diagnostic in the file, checking it whole would find none either: each statement
+ * is checked by the checker of its range. Otherwise the file is checked whole (`startParallelCheck`): the
+ * diagnostics of the ranges can differ from the file's, where they depend on the order the file's
+ * declarations are resolved in. A union type prints its members in the order the checker created them,
+ * and a check that a symbol's first declaration runs reports on all its declarations.
+ */
+export declare function checkSourceFileRange(c: Checker, file: SourceFile, start: number, end: number): boolean;
 /** Checks a statement, declaration, class member or type node. */
 export declare function checkSourceElement(c: Checker, node: Node | undefined): void;
 /** Resolves the `@link` names of a node's JSDoc, which marks what they name referenced. */

package/dist/api/compiler/checker-source-file.js

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

package/dist/api/compiler/checker-symbol-types.js

@@ -26,7 +26,7 @@ import { getTypeForBindingElement, getTypeFromBindingPattern } from './checker-d
 import { checkRightHandSideOfForOf } from './checker-statements.js';
 import { getTypeWithFacts, hasTypeFacts, getNonNullableType } from './checker-flow.js';
 import { getTypeOfModuleExportsSymbol, getWidenedTypeForAssignmentDeclaration } from './checker-javascript.js';
-import { copyDeclarations, getDeclarations, getSymbolId } from './symbol.js';
+import { copyDeclarations, declarationAt, declarationCount, getDeclarations, getSymbolId, } from './symbol.js';
 export function getTypeOfSymbol(c, symbol) {
     const checkFlags = symbol.checkFlags;
     if ((checkFlags & 65536 /* CheckFlags.DeferredType */) !== 0)
@@ -748,11 +748,11 @@ export function isReadonlySymbol(c, symbol) {
             (getDeclarationNodeFlagsFromSymbol(symbol) & 6 /* NodeFlags.Constant */) !== 0) ||
         ((symbol.flags & 98304 /* SymbolFlags.Accessor */) !== 0 && (symbol.flags & 65536 /* SymbolFlags.SetAccessor */) === 0) ||
         (symbol.flags & 8 /* SymbolFlags.EnumMember */) !== 0 ||
-        someReadonlyAssignmentDeclaration(c, getDeclarations(symbol)));
+        someReadonlyAssignmentDeclaration(c, symbol));
 }
-function someReadonlyAssignmentDeclaration(c, declarations) {
-    for (const d of declarations)
-        if (isReadonlyAssignmentDeclaration(c, d))
+function someReadonlyAssignmentDeclaration(c, symbol) {
+    for (let i = 0; i < declarationCount(symbol); i++)
+        if (isReadonlyAssignmentDeclaration(c, declarationAt(symbol, i)))
             return true;
     return false;
 }

package/dist/api/compiler/checker-symbols.js

@@ -697,6 +697,7 @@ function setMergedSymbol(c, id, target) {
         c.mergedSymbolChanges.set(c.mergedSymbols, id, target);
     else
         c.mergedSymbols.set(id, target);
+    c.mergedSymbolIds.add(id);
 }
 /** Merges script locals into globals; ambient modules and augmentations wait for global types. */
 export function initializeGlobals(c) {
@@ -1033,7 +1034,7 @@ function recordMergedSymbol(c, target, source) {
 }
 export function getMergedSymbol(c, symbol) {
     const id = symbol.id;
-    if (id !== 0) {
+    if (id !== 0 && c.mergedSymbolIds.has(id)) {
         const merged = c.mergedSymbols.get(id);
         if (merged !== undefined)
             return merged;
@@ -1459,9 +1460,11 @@ export function symbolIsValue(c, symbol) {
 function isDeclarationContainedBy(symbol, container) {
     const declaration = symbol.valueDeclaration;
     if (declaration !== undefined)
-        for (const d of getDeclarations(container))
+        for (let i = 0; i < declarationCount(container); i++) {
+            const d = declarationAt(container, i);
             if (declaration.pos >= d.pos && declaration.end <= d.end)
                 return true;
+        }
     return false;
 }
 /** Value members other than signatures and index signatures, declared ones first, each part ordered by declaration. */

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

@@ -1,7 +1,7 @@
 import type { DeferredCollisionCheck } from './checker-generated-code.js';
 import type { EmitHelperFileLinks } from './checker-emit-helpers.js';
 import type { Node, PatternAmbientModule, SourceFile } from './ast.js';
-import { CompactSymbolLinkTable, IntLinkTable, LinkTable, SparseLinkTable } from './link-tables.js';
+import { CompactSymbolLinkTable, IntLinkTable, LinkTable, PagedIdSet, SparseLinkTable } from './link-tables.js';
 import { Diagnostic, type DiagnosticMessage, Diagnostics } from './diagnostics.js';
 import { type CompilerOptions, ModuleKind, ScriptTarget } from './options.js';
 import { CheckFlags, Symbol, SymbolFlags, type SymbolTable } from './symbol.js';
@@ -204,6 +204,11 @@ export declare class Checker implements TypeChecking {
     readonly resolvedSignatures: SparseLinkTable<Signature>;
     /** Merged symbols, indexed by the id of the symbol merged into them. */
     readonly mergedSymbols: Map<number, Symbol>;
+    /**
+     * The ids that `mergedSymbols` has, or had: most symbols are merged into none, and `getMergedSymbol`
+     * finds that here without probing the map.
+     */
+    readonly mergedSymbolIds: PagedIdSet;
     /** Globals merged from the default libraries, shared with other checkers. */
     libGlobals: LibGlobals | undefined;
     /** The program's globals and module augmentations as another checker merged them, shared with it. */

package/dist/api/compiler/checker.js

@@ -1,5 +1,5 @@
 import { sideOf } from './side-state.js';
-import { CompactSymbolLinkTable, IntLinkTable, LinkTable, SparseLinkTable } from './link-tables.js';
+import { CompactSymbolLinkTable, IntLinkTable, LinkTable, PagedIdSet, SparseLinkTable } from './link-tables.js';
 import { getErrorRangeForNode, getSourceFileOfNode } from './binder-utilities.js';
 import { Diagnostic, compareDiagnostics } from './diagnostics.js';
 import { ModuleKind, ScriptTarget, getEmitScriptTarget, getIsolatedModules, getStrictOptionValue, shouldPreserveConstEnums, } from './options.js';
@@ -284,6 +284,11 @@ export class Checker {
     resolvedSignatures = new SparseLinkTable();
     /** Merged symbols, indexed by the id of the symbol merged into them. */
     mergedSymbols;
+    /**
+     * The ids that `mergedSymbols` has, or had: most symbols are merged into none, and `getMergedSymbol`
+     * finds that here without probing the map.
+     */
+    mergedSymbolIds = new PagedIdSet();
     /** Globals merged from the default libraries, shared with other checkers. */
     libGlobals;
     /** The program's globals and module augmentations as another checker merged them, shared with it. */
@@ -616,6 +621,8 @@ export class Checker {
             this.globals = libs.copyGlobals();
             this.mergedSymbols = libs.copyMergedSymbols();
         }
+        for (const id of this.mergedSymbols.keys())
+            this.mergedSymbolIds.add(id);
         this.globalThisSymbol = this.newSymbol(1536 /* SymbolFlags.Module */, 'globalThis');
         this.globalThisSymbol.checkFlags = 8 /* CheckFlags.Readonly */;
         this.globalThisSymbol.exports = this.globals;
@@ -890,6 +897,7 @@ export function disposeChecker(c) {
         c.mergedSymbols.clear();
         c.globals.clear();
     }
+    c.mergedSymbolIds.clear();
     c.sharedSymbolCopies.clear();
     c.memberPositionsInLists.clear();
     c.memberNamesOfLists.clear();

package/dist/api/compiler/file-loader.d.ts

@@ -95,10 +95,10 @@ export declare class LoadedFile {
     readonly references: LoadedReference[];
     readonly resolutionsInFile: ModeAwareCache<ResolvedModule> | undefined;
     readonly typeResolutionsInFile: ModeAwareCache<ResolvedTypeReferenceDirective> | undefined;
-    readonly processingDiagnostics: ProcessingDiagnostic[];
+    readonly processingDiagnostics: readonly ProcessingDiagnostic[];
     readonly importHelpersImportSpecifier: StringLiteral | undefined;
     readonly jsxRuntimeImport: JsxRuntimeImport | undefined;
-    constructor(file: SourceFile, isLibFile: boolean, metadata: SourceFileMetadata, references: LoadedReference[], resolutionsInFile: ModeAwareCache<ResolvedModule> | undefined, typeResolutionsInFile: ModeAwareCache<ResolvedTypeReferenceDirective> | undefined, processingDiagnostics: ProcessingDiagnostic[], importHelpersImportSpecifier: StringLiteral | undefined, jsxRuntimeImport: JsxRuntimeImport | undefined);
+    constructor(file: SourceFile, isLibFile: boolean, metadata: SourceFileMetadata, references: LoadedReference[], resolutionsInFile: ModeAwareCache<ResolvedModule> | undefined, typeResolutionsInFile: ModeAwareCache<ResolvedTypeReferenceDirective> | undefined, processingDiagnostics: readonly ProcessingDiagnostic[], importHelpersImportSpecifier: StringLiteral | undefined, jsxRuntimeImport: JsxRuntimeImport | undefined);
 }
 /** Referenced projects, and how their sources map to declaration outputs. */
 export declare class ProjectReferenceMapper {

package/dist/api/compiler/file-loader.js

@@ -165,6 +165,14 @@ class SubTasksAhead {
         this.subTasks = subTasks;
     }
 }
+/** Read in place of a task's lists it has not created. */
+const noParseTasks = [];
+const noTraces = [];
+const noProcessingDiagnostics = [];
+/**
+ * A file to load. Its lists are created on first use: most tasks never get sub-tasks, traces or processing
+ * diagnostics, and large programs create hundreds of thousands of tasks.
+ */
 class ParseTask {
     normalizedFilePath;
     libFile;
@@ -176,15 +184,15 @@ class ParseTask {
     path = '';
     file = undefined;
     redirectedParseTask = undefined;
-    subTasks = [];
+    subTasks = undefined;
     loaded = false;
     startedSubTasks = false;
     metadata = libFileMetadata;
     resolutionsInFile = undefined;
-    resolutionsTrace = [];
+    resolutionsTrace = undefined;
     typeResolutionsInFile = undefined;
-    typeResolutionsTrace = [];
-    processingDiagnostics = [];
+    typeResolutionsTrace = undefined;
+    processingDiagnostics = undefined;
     importHelpersImportSpecifier = undefined;
     jsxRuntimeImport = undefined;
     /** The task of the same file name that was loaded instead of this one. */
@@ -201,7 +209,18 @@ class ParseTask {
         this.packageId = packageId;
     }
     addSubTask(fileName, libFile, reason, increaseDepth, elideOnDepth, packageId) {
-        this.subTasks.push(new ParseTask(normalizePath(fileName), libFile, reason, false, increaseDepth, elideOnDepth, packageId));
+        (this.subTasks ??= []).push(new ParseTask(normalizePath(fileName), libFile, reason, false, increaseDepth, elideOnDepth, packageId));
+    }
+    addProcessingDiagnostic(diagnostic) {
+        (this.processingDiagnostics ??= []).push(diagnostic);
+    }
+    /** Where module resolution traces go under `--traceResolution`; undefined without it. */
+    moduleTraces(trace) {
+        return trace ? (this.resolutionsTrace ??= []) : undefined;
+    }
+    /** Where type reference resolution traces go under `--traceResolution`; undefined without it. */
+    typeTraces(trace) {
+        return trace ? (this.typeResolutionsTrace ??= []) : undefined;
     }
 }
 /** The tasks of one path, by file name casing. */
@@ -640,7 +659,7 @@ export class FileLoader {
             return undefined;
         }
         const references = [];
-        for (const sub of task.subTasks) {
+        for (const sub of task.subTasks ?? noParseTasks) {
             references.push(new LoadedReference(sub.normalizedFilePath, sub.libFile !== undefined ? sub.libFile.name : '', sub.includeReason, sub.increaseDepth, sub.elideOnDepth, sub.packageId));
             const subDepth = sub.increaseDepth ? depth + 1 : depth;
             // `run` skips these.
@@ -655,7 +674,7 @@ export class FileLoader {
         // Traces are reported in the program's order: such programs resolve on their own.
         if (file === undefined || this.options.traceResolution === true)
             return undefined;
-        return new LoadedFile(file, task.libFile !== undefined, task.metadata, references, task.resolutionsInFile, task.typeResolutionsInFile, task.processingDiagnostics, task.importHelpersImportSpecifier, task.jsxRuntimeImport);
+        return new LoadedFile(file, task.libFile !== undefined, task.metadata, references, task.resolutionsInFile, task.typeResolutionsInFile, task.processingDiagnostics ?? noProcessingDiagnostics, task.importHelpersImportSpecifier, task.jsxRuntimeImport);
     }
     // ---- Project references
     loadProjectReferences() {
@@ -737,7 +756,7 @@ export class FileLoader {
             return;
         }
         const task = new ParseTask(absolute, undefined, reason, false, false, false, undefined);
-        task.processingDiagnostics.push(ProcessingDiagnostic.explainingFileInclude('', reason, resolved.message, resolved.args));
+        task.addProcessingDiagnostic(ProcessingDiagnostic.explainingFileInclude('', reason, resolved.message, resolved.args));
         this.rootTasks.push(task);
     }
     isSupportedExtension(canonicalFileName) {
@@ -888,7 +907,8 @@ export class FileLoader {
             }
             if (!taskByFileName.startedSubTasks && loadSubTasks) {
                 taskByFileName.startedSubTasks = true;
-                this.start(taskByFileName.subTasks, data.lowestDepth);
+                if (taskByFileName.subTasks !== undefined)
+                    this.start(taskByFileName.subTasks, data.lowestDepth);
             }
         }
     }
@@ -921,7 +941,7 @@ export class FileLoader {
         if (hasExtension(task.normalizedFilePath) && this.options.allowNonTsExtensions !== true) {
             const canonicalFileName = getCanonicalFileName(task.normalizedFilePath, fs.useCaseSensitiveFileNames);
             if (!this.isSupportedExtension(canonicalFileName)) {
-                task.processingDiagnostics.push(hasJSFileExtension(canonicalFileName)
+                task.addProcessingDiagnostic(hasJSFileExtension(canonicalFileName)
                     ? ProcessingDiagnostic.explainingFileInclude('', task.includeReason, 1519 /* Diagnostics.File_0_is_a_JavaScript_file_Did_you_mean_to_enable_the_allowJs_option */, [task.normalizedFilePath])
                     : ProcessingDiagnostic.explainingFileInclude('', task.includeReason, 1230 /* Diagnostics.File_0_has_an_unsupported_extension_The_only_supported_extensions_are_1 */, [task.normalizedFilePath, this.supportedExtensionsList()]));
                 return;
@@ -955,7 +975,7 @@ export class FileLoader {
                 const reason = FileIncludeReason.reference(3 /* FileIncludeKind.LibReferenceDirective */, task.path, i, undefined);
                 const name = getLibFileName(file.libReferenceDirectives[i].fileName);
                 if (name === '') {
-                    task.processingDiagnostics.push(ProcessingDiagnostic.unknownReference(reason));
+                    task.addProcessingDiagnostic(ProcessingDiagnostic.unknownReference(reason));
                     continue;
                 }
                 const libFile = this.pathForLibFile(name);
@@ -975,7 +995,7 @@ export class FileLoader {
         else
             task.subTasks = this.subTasksOf(loaded);
         for (const diagnostic of loaded.processingDiagnostics)
-            task.processingDiagnostics.push(diagnostic.copy());
+            task.addProcessingDiagnostic(diagnostic.copy());
         task.resolutionsInFile = loaded.resolutionsInFile;
         task.typeResolutionsInFile = loaded.typeResolutionsInFile;
         task.importHelpersImportSpecifier = loaded.importHelpersImportSpecifier;
@@ -1002,7 +1022,7 @@ export class FileLoader {
         const reason = FileIncludeReason.reference(1 /* FileIncludeKind.ReferenceFile */, this.toPath(containingFile), index, undefined);
         const resolved = this.getSourceFileFromReference(normalizePath(referencedFileName), moduleName, containingFile, reason);
         if (typeof resolved !== 'string') {
-            task.processingDiagnostics.push(ProcessingDiagnostic.explainingFileInclude('', reason, resolved.message, resolved.args));
+            task.addProcessingDiagnostic(ProcessingDiagnostic.explainingFileInclude('', reason, resolved.message, resolved.args));
             return;
         }
         task.addSubTask(resolved, undefined, reason, false, false, undefined);
@@ -1020,14 +1040,14 @@ export class FileLoader {
             const mode = reference.resolutionMode !== ModuleKind.None
                 ? reference.resolutionMode
                 : getDefaultResolutionModeForFile(file.fileName, task.metadata, options);
-            const resolved = this.resolver.resolveTypeReferenceDirective(reference.fileName, containingFile, mode, redirect?.resolved, task.typeResolutionsTrace);
+            const resolved = this.resolver.resolveTypeReferenceDirective(reference.fileName, containingFile, mode, redirect?.resolved, task.typeTraces(this.options.traceResolution === true));
             resolutions.set(modeAwareKey(reference.fileName, mode), resolved);
             const reason = FileIncludeReason.reference(2 /* FileIncludeKind.TypeReferenceDirective */, task.path, i, undefined);
             if (resolved.resolvedFileName !== '') {
                 task.addSubTask(resolved.resolvedFileName, undefined, reason, resolved.isExternalLibraryImport, false, resolved.packageId);
             }
             else {
-                task.processingDiagnostics.push(ProcessingDiagnostic.unknownReference(reason));
+                task.addProcessingDiagnostic(ProcessingDiagnostic.unknownReference(reason));
             }
         }
         task.typeResolutionsInFile = resolutions;
@@ -1039,13 +1059,13 @@ export class FileLoader {
         const resolutions = new Map();
         for (const name of names) {
             // Resolved without a mode: CommonJS under node16/nodenext, `import` conditions under bundler.
-            const resolved = this.resolver.resolveTypeReferenceDirective(name, task.normalizedFilePath, ModuleKind.None, undefined, task.typeResolutionsTrace);
+            const resolved = this.resolver.resolveTypeReferenceDirective(name, task.normalizedFilePath, ModuleKind.None, undefined, task.typeTraces(this.options.traceResolution === true));
             resolutions.set(modeAwareKey(name, ModuleKind.None), resolved);
             if (resolved.resolvedFileName !== '') {
                 task.addSubTask(resolved.resolvedFileName, undefined, FileIncludeReason.automaticTypeDirective(name, resolved.packageId), resolved.isExternalLibraryImport, false, resolved.packageId);
             }
             else {
-                task.processingDiagnostics.push(ProcessingDiagnostic.explainingFileInclude('', FileIncludeReason.automaticTypeDirective(name, undefined), 821 /* Diagnostics.Cannot_find_type_definition_file_for_0 */, [name]));
+                task.addProcessingDiagnostic(ProcessingDiagnostic.explainingFileInclude('', FileIncludeReason.automaticTypeDirective(name, undefined), 821 /* Diagnostics.Cannot_find_type_definition_file_for_0 */, [name]));
             }
         }
         task.typeResolutionsInFile = resolutions;
@@ -1083,7 +1103,7 @@ export class FileLoader {
             if (moduleName === '')
                 continue;
             const mode = getModeForUsageLocation(file.fileName, task.metadata, entry, options);
-            const resolved = this.resolver.resolveModuleName(moduleName, containingFile, mode, redirect?.resolved, task.resolutionsTrace);
+            const resolved = this.resolver.resolveModuleName(moduleName, containingFile, mode, redirect?.resolved, task.moduleTraces(this.options.traceResolution === true));
             resolutions.set(modeAwareKey(moduleName, mode), resolved);
             const resolvedFileName = resolved.resolvedFileName;
             if (resolvedFileName === '')
@@ -1169,9 +1189,9 @@ export class FileLoader {
                         tasksSeenByNameIgnoreCase.set(lowerCasePath, task);
                     }
                 }
-                for (const trace of task.typeResolutionsTrace)
+                for (const trace of task.typeResolutionsTrace ?? noTraces)
                     host.trace(trace);
-                for (const trace of task.resolutionsTrace)
+                for (const trace of task.resolutionsTrace ?? noTraces)
                     host.trace(trace);
                 const file = task.file;
                 const packageId = data.packageId;
@@ -1193,7 +1213,7 @@ export class FileLoader {
                     if (file !== undefined)
                         packageIdToSourceFile.set(key, file);
                 }
-                if (task.subTasks.length > 0)
+                if (task.subTasks !== undefined && task.subTasks.length > 0)
                     collectFiles(task.subTasks);
                 const redirected = task.redirectedParseTask;
                 if (redirected !== undefined) {
@@ -1202,12 +1222,12 @@ export class FileLoader {
                 }
                 if (task.isForAutomaticTypeDirective) {
                     typeResolutionsInFile.set(task.path, task.typeResolutionsInFile);
-                    for (const diagnostic of task.processingDiagnostics)
+                    for (const diagnostic of task.processingDiagnostics ?? noProcessingDiagnostics)
                         includeProcessor.addProcessingDiagnostic(diagnostic);
                     continue;
                 }
                 const path = task.path;
-                for (const diagnostic of task.processingDiagnostics)
+                for (const diagnostic of task.processingDiagnostics ?? noProcessingDiagnostics)
                     includeProcessor.addProcessingDiagnostic(diagnostic);
                 if (file === undefined) {
                     missingFiles.push(task.normalizedFilePath);

package/dist/api/compiler/link-tables.d.ts

@@ -58,6 +58,13 @@ export declare class ClusteredIntLinkTable {
     set(id: number, value: number): void;
     private pageOf;
 }
+/** Ids in pages of `IdSetPaging.Ids` ids, one bit each; a page is created by the first id added to it. */
+export declare class PagedIdSet {
+    readonly pages: (Int32Array | undefined)[];
+    has(id: number): boolean;
+    add(id: number): void;
+    clear(): void;
+}
 /**
  * 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

package/dist/api/compiler/link-tables.js

@@ -146,6 +146,28 @@ export class ClusteredIntLinkTable {
         return this.lastPage;
     }
 }
+/** Ids in pages of `IdSetPaging.Ids` ids, one bit each; a page is created by the first id added to it. */
+export class PagedIdSet {
+    pages = [];
+    has(id) {
+        const page = this.pages[id >> 13 /* IdSetPaging.Bits */];
+        return page !== undefined && (page[(id >> 5) & 255 /* IdSetPaging.WordMask */] & (1 << (id & 31))) !== 0;
+    }
+    add(id) {
+        const index = id >> 13 /* IdSetPaging.Bits */;
+        let page = this.pages[index];
+        if (page === undefined) {
+            while (this.pages.length <= index)
+                this.pages.push(undefined);
+            page = new Int32Array(256 /* IdSetPaging.Words */);
+            this.pages[index] = page;
+        }
+        page[(id >> 5) & 255 /* IdSetPaging.WordMask */] |= 1 << (id & 31);
+    }
+    clear() {
+        this.pages.length = 0;
+    }
+}
 /** The number of set bits of a 32-bit value. */
 function bitCount(x) {
     x = x - ((x >>> 1) & 0x55555555);

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

@@ -135,6 +135,8 @@ export declare class Parser extends ScannerErrorReporter {
     reparseList: Node[];
     private readonly reparseLists;
     private reparseDepth;
+    private readonly listScratch;
+    private listDepth;
     reparsedClones: Node[];
     /** Nodes with eagerly parsed JSDoc, for rewinding. */
     jsDocInfos: Node[];
@@ -209,6 +211,11 @@ export declare class Parser extends ScannerErrorReporter {
     parseList(kind: ParsingContext, element: ListElement): NodeList;
     /** The list, or undefined if an element parser returned undefined. */
     parseDelimitedList(kind: ParsingContext, element: ListElement): NodeList | undefined;
+    /** The scratch array for a list at the next nesting depth, empty. */
+    private openList;
+    /** The elements collected in `list` (the scratch array from `openList`) as an array of their exact
+     * length, or the shared empty array; empties the scratch array for the next list at its depth. */
+    private closeList;
     /** The list; a missing list if `opening` is absent; undefined if an element parser returned undefined. */
     parseBracketedList(kind: ParsingContext, element: ListElement, opening: SyntaxKind, closing: SyntaxKind): NodeList | undefined;
     parseEmptyNodeList(): NodeList;