tsc-ts 0.0.8 → 0.0.10

package/dist/api/compiler/diagnostics.js

@@ -326,6 +326,11 @@ export class Diagnostic {
     reportsDeprecated;
     skippedOnNoEmit = false;
     repopulateInfo = undefined;
+    /**
+     * What `formatDiagnostic` gives for this diagnostic in `formattedReports.format`, where the checker
+     * thread that found it formatted it (`packResult`); `''` otherwise.
+     */
+    formatted = '';
     constructor(file, pos, end, message, args = []) {
         this.file = file;
         this.pos = pos;
@@ -358,6 +363,7 @@ export class Diagnostic {
         result.relatedInformation = this.relatedInformation;
         result.skippedOnNoEmit = this.skippedOnNoEmit;
         result.repopulateInfo = this.repopulateInfo;
+        result.formatted = this.formatted;
         return result;
     }
 }
@@ -463,10 +469,12 @@ function compareRelatedInfo(a, b) {
 export function compareDiagnostics(a, b) {
     if (a === b)
         return 0;
-    let c = compareCodePoints(fileNameOf(a), fileNameOf(b));
-    if (c !== 0)
-        return c;
-    c = a.pos - b.pos;
+    const c = compareCodePoints(fileNameOf(a), fileNameOf(b));
+    return c !== 0 ? c : compareDiagnosticsInFile(a, b);
+}
+/** `compareDiagnostics` of two diagnostics whose files have the same name. */
+function compareDiagnosticsInFile(a, b) {
+    let c = a.pos - b.pos;
     if (c !== 0)
         return c;
     c = a.end - b.end;
@@ -486,6 +494,66 @@ export function compareDiagnostics(a, b) {
         return c;
     return compareRelatedInfo(a.relatedInformation, b.relatedInformation);
 }
+/**
+ * `diagnostics` in the order of `compareDiagnostics`, equal ones in their order in `diagnostics`. File
+ * names are compared once per pair of files rather than once per pair of diagnostics: the distinct
+ * files are sorted by name, and each diagnostic sorts by its file's place in that order, then by the
+ * rest of `compareDiagnostics`. A program's diagnostics come a file at a time, so the files are found
+ * from the runs of one file.
+ */
+export function sortDiagnostics(diagnostics) {
+    const n = diagnostics.length;
+    if (n < 2)
+        return diagnostics.slice();
+    const fileIndices = new Map();
+    const files = [];
+    const fileOf = [];
+    let last = undefined;
+    let lastIndex = -1;
+    for (let i = 0; i < n; i++) {
+        const file = diagnostics[i].file;
+        if (lastIndex < 0 || file !== last) {
+            let k = fileIndices.get(file);
+            if (k === undefined) {
+                k = files.length;
+                fileIndices.set(file, k);
+                files.push(file);
+            }
+            last = file;
+            lastIndex = k;
+        }
+        fileOf.push(lastIndex);
+    }
+    // Files with the same name share a rank, as they compare equal.
+    const nameOf = (k) => {
+        const file = files[k];
+        return file === undefined ? '' : file.fileName;
+    };
+    const byName = [];
+    for (let k = 0; k < files.length; k++)
+        byName.push(k);
+    byName.sort((x, y) => compareCodePoints(nameOf(x), nameOf(y)));
+    const rank = [];
+    for (let k = 0; k < files.length; k++)
+        rank.push(0);
+    for (let k = 1; k < byName.length; k++)
+        rank[byName[k]] = rank[byName[k - 1]] + (nameOf(byName[k]) === nameOf(byName[k - 1]) ? 0 : 1);
+    const order = [];
+    for (let i = 0; i < n; i++)
+        order.push(i);
+    order.sort((x, y) => {
+        const c = rank[fileOf[x]] - rank[fileOf[y]];
+        if (c !== 0)
+            return c;
+        const a = diagnostics[x];
+        const b = diagnostics[y];
+        return a === b ? 0 : compareDiagnosticsInFile(a, b);
+    });
+    const sorted = [];
+    for (const i of order)
+        sorted.push(diagnostics[i]);
+    return sorted;
+}
 function equalChain(a, b) {
     if (a.length !== b.length)
         return false;
@@ -567,13 +635,27 @@ function formatDiagnosticIn(diagnostic, fileName, options) {
     result += `${categoryName(diagnostic.category)} TS${diagnostic.code}: `;
     return result + flattenDiagnosticMessage(diagnostic, options.newLine, options.locale) + options.newLine;
 }
+/**
+ * The plain format the main thread reports a compilation's diagnostics in (`DiagnosticReporter.plainFormat`),
+ * which its checker threads receive a copy of and format the diagnostics they send back in
+ * (`Diagnostic.formatted`). Unset where diagnostics are reported with color and context, or not at all.
+ */
+export class FormattedReports {
+    format = undefined;
+}
+export const formattedReports = new FormattedReports();
 /** `formatDiagnostic` of each diagnostic. */
 export function formatDiagnostics(diagnostics, options) {
     let result = '';
+    const formatted = options === formattedReports.format;
     // Sorted diagnostics come a file at a time: the relative name of the last file is kept.
     let lastFile = undefined;
     let lastName = '';
     for (const diagnostic of diagnostics) {
+        if (formatted && diagnostic.formatted !== '') {
+            result += diagnostic.formatted;
+            continue;
+        }
         const file = diagnostic.file;
         if (file !== undefined && file !== lastFile) {
             lastFile = file;

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 {
@@ -147,6 +147,11 @@ export declare class ProcessedFiles {
      * threads (`preparedPackageJsonLookups`); `undefined` where they may miss some.
      */
     readonly preparedPackageJsons: readonly PackageJsonLookup[] | undefined;
+    /**
+     * The files each file's imports and type reference directives added to the program, by index into
+     * `files`, without the file itself.
+     */
+    readonly addedFiles: readonly (readonly number[])[];
     constructor(resolver: Resolver, 
     /** Libraries first, sorted, then other files in load order. */
     files: readonly SourceFile[], filesByPath: ReadonlyMap<string, SourceFile>, missingFiles: readonly string[], resolvedModules: ReadonlyMap<string, ModeAwareCache<ResolvedModule> | undefined>, typeResolutionsInFile: ReadonlyMap<string, ModeAwareCache<ResolvedTypeReferenceDirective> | undefined>, sourceFileMetadata: ReadonlyMap<string, SourceFileMetadata>, jsxRuntimeImports: ReadonlyMap<string, JsxRuntimeImport>, importHelpersImportSpecifiers: ReadonlyMap<string, StringLiteral>, libFiles: ReadonlyMap<string, LibFile>, 
@@ -158,7 +163,12 @@ export declare class ProcessedFiles {
      * The `package.json` lookups made resolving the files whose resolutions were taken from parse
      * threads (`preparedPackageJsonLookups`); `undefined` where they may miss some.
      */
-    preparedPackageJsons: readonly PackageJsonLookup[] | undefined);
+    preparedPackageJsons: readonly PackageJsonLookup[] | undefined, 
+    /**
+     * The files each file's imports and type reference directives added to the program, by index into
+     * `files`, without the file itself.
+     */
+    addedFiles: readonly (readonly number[])[]);
 }
 /** The files of `processed` with `file` in place of the file at its path, for `Program.updateFile`. */
 export declare function withReplacedFile(processed: ProcessedFiles, file: SourceFile): ProcessedFiles;

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,19 +184,21 @@ 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. */
     loadedTask = undefined;
+    /** Whether an import or a type reference directive adds the file (`ProcessedFiles.addedFiles`). */
+    byImport;
     constructor(normalizedFilePath, libFile, includeReason, isForAutomaticTypeDirective, increaseDepth, 
     /** A JavaScript file found in `node_modules`, loaded only within `maxNodeModuleJsDepth`. */
     elideOnDepth, packageId) {
@@ -199,17 +209,37 @@ class ParseTask {
         this.increaseDepth = increaseDepth;
         this.elideOnDepth = elideOnDepth;
         this.packageId = packageId;
+        const kind = includeReason !== undefined ? includeReason.kind : -1;
+        this.byImport = kind === 0 /* FileIncludeKind.Import */ || kind === 2 /* FileIncludeKind.TypeReferenceDirective */;
     }
     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;
     }
 }
+const noData = [];
 /** The tasks of one path, by file name casing. */
 class ParseTaskData {
     tasks = new Map();
     lowestDepth = Number.MAX_SAFE_INTEGER;
     startedSubTasks = false;
     packageId = undefined;
+    /** The index of this path's file in the program's files, once collected; -1 for none. */
+    index = -1;
+    /** For a deduplicated package's path, the tasks of the copy kept (`collect`). */
+    keptCopy = undefined;
+    /** The paths the file's imports and type reference directives add, once collected. */
+    added = noData;
     constructor(task) {
         this.tasks.set(task.normalizedFilePath, task);
     }
@@ -321,6 +351,7 @@ export class ProcessedFiles {
     redirectFilesByPath;
     projectReferenceMapper;
     preparedPackageJsons;
+    addedFiles;
     constructor(resolver, 
     /** Libraries first, sorted, then other files in load order. */
     files, filesByPath, missingFiles, resolvedModules, typeResolutionsInFile, sourceFileMetadata, jsxRuntimeImports, importHelpersImportSpecifiers, libFiles, 
@@ -332,7 +363,12 @@ export class ProcessedFiles {
      * The `package.json` lookups made resolving the files whose resolutions were taken from parse
      * threads (`preparedPackageJsonLookups`); `undefined` where they may miss some.
      */
-    preparedPackageJsons) {
+    preparedPackageJsons, 
+    /**
+     * The files each file's imports and type reference directives added to the program, by index into
+     * `files`, without the file itself.
+     */
+    addedFiles) {
         this.resolver = resolver;
         this.files = files;
         this.filesByPath = filesByPath;
@@ -350,6 +386,7 @@ export class ProcessedFiles {
         this.redirectFilesByPath = redirectFilesByPath;
         this.projectReferenceMapper = projectReferenceMapper;
         this.preparedPackageJsons = preparedPackageJsons;
+        this.addedFiles = addedFiles;
     }
 }
 /** The files of `processed` with `file` in place of the file at its path, for `Program.updateFile`. */
@@ -358,7 +395,9 @@ export function withReplacedFile(processed, file) {
     files[files.findIndex((f) => f.path === file.path)] = file;
     const filesByPath = new Map(processed.filesByPath);
     filesByPath.set(file.path, file);
-    return new ProcessedFiles(processed.resolver, files, filesByPath, processed.missingFiles, processed.resolvedModules, processed.typeResolutionsInFile, processed.sourceFileMetadata, processed.jsxRuntimeImports, processed.importHelpersImportSpecifiers, processed.libFiles, processed.sourceFilesFoundSearchingNodeModules, processed.includeProcessor.copy(file.path), processed.outputFileToProjectReferenceSource, processed.redirectTargets, processed.redirectFilesByPath, processed.projectReferenceMapper, processed.preparedPackageJsons);
+    return new ProcessedFiles(processed.resolver, files, filesByPath, processed.missingFiles, processed.resolvedModules, processed.typeResolutionsInFile, processed.sourceFileMetadata, processed.jsxRuntimeImports, processed.importHelpersImportSpecifiers, processed.libFiles, processed.sourceFilesFoundSearchingNodeModules, processed.includeProcessor.copy(file.path), processed.outputFileToProjectReferenceSource, processed.redirectTargets, processed.redirectFilesByPath, processed.projectReferenceMapper, processed.preparedPackageJsons, 
+    // The file has the same references (`canReplaceFile`), and keeps its index.
+    processed.addedFiles);
 }
 /** Whether `file` imports the `importHelpers` module (tslib) under `options`. */
 export function needsImportHelpersImportSpecifier(file, options) {
@@ -640,7 +679,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 +694,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 +776,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 +927,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 +961,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 +995,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 +1015,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 +1042,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 +1060,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 +1079,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 +1123,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 === '')
@@ -1134,9 +1174,16 @@ export class FileLoader {
         const packageIdToSourceFile = new Map();
         const checkCasing = this.options.forceConsistentCasingInFileNames !== false;
         const seen = new Map();
-        const collectFiles = (tasks) => {
+        // The paths each file's imports and type reference directives add (the tasks of each path), for
+        // `ProcessedFiles.addedFiles`: recorded while collecting visits them, as their files are only known
+        // once every file is collected.
+        const fileData = [];
+        const libData = new Map();
+        const packageIdToData = new Map();
+        const collectFiles = (tasks, added) => {
             for (let task of tasks) {
                 const includeReason = task.includeReason;
+                const byImport = task.byImport;
                 // Automatic type directive tasks are an implementation detail, not a reason.
                 if (task.redirectedParseTask === undefined && !task.isForAutomaticTypeDirective) {
                     if (task.loadedTask !== undefined)
@@ -1145,6 +1192,8 @@ export class FileLoader {
                         addIncludeReason(includeProcessor, task, includeReason);
                 }
                 const data = this.taskDataByPath.get(task.path);
+                if (added !== undefined && data !== undefined && byImport)
+                    added.push(data);
                 if (!task.loaded || data === undefined)
                     continue;
                 const checkedName = seen.get(data);
@@ -1169,9 +1218,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;
@@ -1186,15 +1235,19 @@ export class FileLoader {
                             targets.push(task.normalizedFilePath);
                         redirectFilesByPath.set(task.path, new RedirectFile(files.length + redirectFilesByPath.size, task.normalizedFilePath, task.path, packageIdFile.path));
                         filesByPath.set(task.path, packageIdFile);
+                        data.keptCopy = packageIdToData.get(key);
                         if (data.lowestDepth > 0)
                             sourceFilesFoundSearchingNodeModules.add(task.path);
                         continue;
                     }
-                    if (file !== undefined)
+                    if (file !== undefined) {
                         packageIdToSourceFile.set(key, file);
+                        packageIdToData.set(key, data);
+                    }
                 }
-                if (task.subTasks.length > 0)
-                    collectFiles(task.subTasks);
+                let own = undefined;
+                if (task.subTasks !== undefined && task.subTasks.length > 0)
+                    collectFiles(task.subTasks, (own = []));
                 const redirected = task.redirectedParseTask;
                 if (redirected !== undefined) {
                     outputFileToProjectReferenceSource.set(redirected.path, task.normalizedFilePath);
@@ -1202,12 +1255,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);
@@ -1215,11 +1268,15 @@ export class FileLoader {
                 }
                 if (task.libFile !== undefined) {
                     libFiles.push(file);
+                    libData.set(file, data);
                     libFilesByPath.set(path, task.libFile);
                 }
                 else {
                     files.push(file);
+                    fileData.push(data);
                 }
+                if (own !== undefined)
+                    data.added = own;
                 filesByPath.set(path, file);
                 resolvedModules.set(path, task.resolutionsInFile);
                 typeResolutionsInFile.set(path, task.typeResolutionsInFile);
@@ -1233,7 +1290,7 @@ export class FileLoader {
                     sourceFilesFoundSearchingNodeModules.add(path);
             }
         };
-        collectFiles(this.rootTasks);
+        collectFiles(this.rootTasks, undefined);
         const priorities = new Map();
         for (const file of libFiles)
             priorities.set(file, this.libFilePriority(file));
@@ -1241,6 +1298,25 @@ export class FileLoader {
         const allFiles = [...libFiles, ...files];
         for (const redirect of redirectFilesByPath.values())
             redirect.index += libFiles.length;
+        // The files a file adds, without reading its resolutions again or looking up their paths.
+        const dataOfFiles = [];
+        for (const file of libFiles)
+            dataOfFiles.push(libData.get(file));
+        for (const data of fileData)
+            dataOfFiles.push(data);
+        for (let i = 0; i < dataOfFiles.length; i++)
+            dataOfFiles[i].index = i;
+        const addedFiles = [];
+        for (let i = 0; i < dataOfFiles.length; i++) {
+            const added = [];
+            for (const data of dataOfFiles[i].added) {
+                const kept = data.keptCopy;
+                const k = kept !== undefined ? kept.index : data.index;
+                if (k >= 0 && k !== i)
+                    added.push(k);
+            }
+            addedFiles.push(added);
+        }
         const keys = [...this.libResolutions.keys()].sort();
         for (const key of keys) {
             const resolution = this.libResolutions.get(key);
@@ -1252,7 +1328,7 @@ export class FileLoader {
             for (const trace of resolution.trace)
                 host.trace(trace);
         }
-        return new ProcessedFiles(this.resolver, allFiles, filesByPath, missingFiles, resolvedModules, typeResolutionsInFile, sourceFileMetadata, jsxRuntimeImports, importHelpersImportSpecifiers, libFilesByPath, sourceFilesFoundSearchingNodeModules, includeProcessor, outputFileToProjectReferenceSource, redirectTargets, redirectFilesByPath, this.mapper, this.tookPreparedResolutions ? preparedPackageJsonLookups() : noPackageJsonLookups);
+        return new ProcessedFiles(this.resolver, allFiles, filesByPath, missingFiles, resolvedModules, typeResolutionsInFile, sourceFileMetadata, jsxRuntimeImports, importHelpersImportSpecifiers, libFilesByPath, sourceFilesFoundSearchingNodeModules, includeProcessor, outputFileToProjectReferenceSource, redirectTargets, redirectFilesByPath, this.mapper, this.tookPreparedResolutions ? preparedPackageJsonLookups() : noPackageJsonLookups, addedFiles);
     }
 }
 const noPackageJsonLookups = [];

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/parallel-parse.d.ts

@@ -128,7 +128,7 @@ export declare function fileSize(fileName: string): number;
  * Then, for the same reason, large files, one per chunk: root files (TypeScript's 3 MB `checker.ts`,
  * which in a chunk of root files kept one thread busy after the others were done) and the files the
  * parse threads found (`csstype`'s 0.9 MB of declarations, found through React's). The other files go
- * out in program order, in chunks of up to `maxChunk`.
+ * out in program order, in chunks of up to `maxChunk` files and about `maxChunkBytes` of text.
  */
 export declare class ParseQueue {
     private readonly libraries;
@@ -148,7 +148,8 @@ export declare class ParseQueue {
     left(): number;
     /**
      * The next chunk for one of `threads` parse threads, or `undefined` when nothing is left. With
-     * `full`, other files only go out `maxChunk` at a time, and stay queued until there are as many.
+     * `full`, other files only go out in full chunks, `maxChunk` files or `maxChunkBytes` of text, and stay
+     * queued until there are as many.
      */
     next(threads: number, full?: boolean): LoadMessage | undefined;
 }

package/dist/api/compiler/parallel-parse.js

@@ -187,6 +187,12 @@ export function fileSize(fileName) {
 const maxChunk = 16;
 /** Files from this size (bytes) on take a parse thread 25 ms or more, and go out ahead of others. */
 const largeFile = 256 * 1024;
+/**
+ * The most text (bytes) a chunk of other files holds, about one large file's: a chunk ends with the file
+ * that reaches it. Sixteen of tsc-ts's own compiler sources, 50-200 KB each, made one chunk that kept its
+ * thread busy for 30-45 ms after the others were done.
+ */
+const maxChunkBytes = largeFile;
 /**
  * The files to hand out to parse threads, each queued once. Library files go out first, one per
  * chunk, also those found later through `/// <reference lib>`: a large one (`lib.dom.d.ts`) takes a
@@ -194,7 +200,7 @@ const largeFile = 256 * 1024;
  * Then, for the same reason, large files, one per chunk: root files (TypeScript's 3 MB `checker.ts`,
  * which in a chunk of root files kept one thread busy after the others were done) and the files the
  * parse threads found (`csstype`'s 0.9 MB of declarations, found through React's). The other files go
- * out in program order, in chunks of up to `maxChunk`.
+ * out in program order, in chunks of up to `maxChunk` files and about `maxChunkBytes` of text.
  */
 export class ParseQueue {
     libraries = new LoadJobs();
@@ -238,7 +244,8 @@ export class ParseQueue {
     }
     /**
      * The next chunk for one of `threads` parse threads, or `undefined` when nothing is left. With
-     * `full`, other files only go out `maxChunk` at a time, and stay queued until there are as many.
+     * `full`, other files only go out in full chunks, `maxChunk` files or `maxChunkBytes` of text, and stay
+     * queued until there are as many.
      */
     next(threads, full = false) {
         const libraries = this.libraries;
@@ -263,11 +270,16 @@ export class ParseQueue {
         }
         const queue = this.others;
         const left = queue.names.length - this.head;
-        if (left <= 0 || (full && left < maxChunk))
+        if (left <= 0)
             return undefined;
-        const size = full ? maxChunk : Math.min(maxChunk, Math.max(1, Math.floor(left / threads)));
+        const most = full ? maxChunk : Math.min(maxChunk, Math.max(1, Math.floor(left / threads)));
         const start = this.head;
-        const end = start + size;
+        let end = start;
+        let bytes = 0;
+        while (end < queue.names.length && end - start < most && bytes < maxChunkBytes)
+            bytes += queue.sizes[end++];
+        if (full && end - start < maxChunk && bytes < maxChunkBytes)
+            return undefined;
         this.head = end;
         return {
             stop: false,