tsc-ts 0.0.5 → 0.0.7

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

@@ -32,9 +32,8 @@ export declare function localizeMessage(locale: Locale, message: DiagnosticMessa
 export declare function formatMessage(text: string, args: readonly string[]): string;
 /**
  * Makes this thread compute the caches of files that do not have them yet in copies of its own: the
- * files may be published (immutable) and shared with other threads. Declaration files leave the
- * parser without them (`Parser.parseSourceFile`): they make up most of the text of a typical program,
- * and are rarely checked or pointed into by a diagnostic.
+ * files may be published (immutable) and shared with other threads. Files leave the parser without
+ * them (`Parser.parseSourceFile`): most files are never pointed into by a diagnostic.
  */
 export declare function useThreadTextCaches(): void;
 /** The text of a file diagnostics point into. */
@@ -51,11 +50,6 @@ export declare class DiagnosticFile {
      * thread's copy where the file may be shared (`useThreadTextCaches`).
      */
     computeCaches(): void;
-    /**
-     * Like `computeCaches`, from the text's UTF-16 code units `units[0, text.length)`, so the text
-     * itself is neither searched nor copied.
-     */
-    computeCachesFromUnits(units: Uint16Array): void;
     /** Start offsets of each line, split at CR, LF, CRLF, LS and PS. */
     getLineStarts(): readonly number[];
     private nonASCIIStarts;

package/dist/api/compiler/diagnostics.js

@@ -125,14 +125,14 @@ function toWellFormed(text) {
 /**
  * Where this thread computes the line starts and UTF-8 offsets of files that may be shared with other
  * threads (`useThreadTextCaches`): a copy of each such file, by file, that computes them in place.
- * Files leave the parser with line starts, except declaration files, and without UTF-8 offsets.
+ * Files leave the parser without line starts and UTF-8 offsets, except JSON files, which have line
+ * starts.
  */
 let threadCopies = undefined;
 /**
  * Makes this thread compute the caches of files that do not have them yet in copies of its own: the
- * files may be published (immutable) and shared with other threads. Declaration files leave the
- * parser without them (`Parser.parseSourceFile`): they make up most of the text of a typical program,
- * and are rarely checked or pointed into by a diagnostic.
+ * files may be published (immutable) and shared with other threads. Files leave the parser without
+ * them (`Parser.parseSourceFile`): most files are never pointed into by a diagnostic.
  */
 export function useThreadTextCaches() {
     if (threadCopies === undefined)
@@ -152,21 +152,14 @@ function threadCopyOf(file) {
     }
     return copy;
 }
-/** The position of the first code unit at or after `pos` that is a CR or below, or not ASCII; or `end`. */
-function skipPlainASCII(units, pos, end) {
-    for (let i = pos | 0; i < end; i = (i + 1) | 0) {
-        const c = units[i] | 0;
-        if (c <= 13 /* CharacterCodes.carriageReturn */ || c >= 0x80)
-            return i;
-    }
-    return end;
-}
+/** The empty value of a file's position tables until they are computed. */
+const noNumbers = [];
 /** The text of a file diagnostics point into. */
 export class DiagnosticFile {
     fileName;
     text;
     // Computed on first use; never empty once computed.
-    lineStarts = [];
+    lineStarts = noNumbers;
     /** Whether this is a thread's copy of a possibly shared file (`threadCopyOf`). */
     isThreadCopy = false;
     constructor(fileName, text) {
@@ -182,33 +175,6 @@ export class DiagnosticFile {
         if (this.lineStarts.length === 0)
             this.lineStarts = computeLineStarts(this.text);
     }
-    /**
-     * Like `computeCaches`, from the text's UTF-16 code units `units[0, text.length)`, so the text
-     * itself is neither searched nor copied.
-     */
-    computeCachesFromUnits(units) {
-        const text = this.text;
-        // ASCII texts are searched faster than walked.
-        if (this.lineStarts.length !== 0 || Buffer.byteLength(text, 'utf8') === text.length) {
-            this.computeCaches();
-            return;
-        }
-        const length = text.length | 0;
-        const lineStarts = [0];
-        // Visit only the code units that may break a line; `skipPlainASCII` runs over the rest without
-        // calls, so native builds keep its loop on registers. A CR followed by an LF leaves the line start
-        // to the LF.
-        for (let i = skipPlainASCII(units, 0, length); i < length; i = skipPlainASCII(units, (i + 1) | 0, length)) {
-            const ch = units[i] | 0;
-            if (ch === 10 /* CharacterCodes.lineFeed */ ||
-                (ch === 13 /* CharacterCodes.carriageReturn */ &&
-                    (i + 1 >= length || (units[(i + 1) | 0] | 0) !== 10 /* CharacterCodes.lineFeed */)) ||
-                ch === 8232 /* CharacterCodes.lineSeparator */ ||
-                ch === 8233 /* CharacterCodes.paragraphSeparator */)
-                lineStarts.push(i + 1);
-        }
-        this.lineStarts = lineStarts;
-    }
     /** Start offsets of each line, split at CR, LF, CRLF, LS and PS. */
     getLineStarts() {
         if (this.lineStarts.length === 0) {
@@ -222,8 +188,8 @@ export class DiagnosticFile {
     // The non-ASCII characters, in order: their UTF-16 offsets, UTF-8 lengths, and the UTF-8 bytes
     // beyond one per UTF-16 code unit of the text up to and including each. Unset until first used.
     nonASCIIStarts = undefined;
-    nonASCIILengths = [];
-    extraBytes = [];
+    nonASCIILengths = noNumbers;
+    extraBytes = noNumbers;
     getNonASCIIStarts() {
         let starts = this.nonASCIIStarts;
         if (starts === undefined) {
@@ -232,8 +198,8 @@ export class DiagnosticFile {
             if (Buffer.byteLength(text, 'utf8') !== text.length) {
                 // Scanning the UTF-8 encoding is faster than reading each code unit.
                 const bytes = Buffer.from(text, 'utf8');
-                const lengths = this.nonASCIILengths;
-                const extraBytes = this.extraBytes;
+                const lengths = [];
+                const extraBytes = [];
                 let extra = 0;
                 for (let i = 0; i < bytes.length; i++) {
                     const b = bytes[i];
@@ -247,6 +213,8 @@ export class DiagnosticFile {
                     extraBytes.push(extra);
                     i += length - 1;
                 }
+                this.nonASCIILengths = lengths;
+                this.extraBytes = extraBytes;
             }
             this.nonASCIIStarts = starts;
         }

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

@@ -14,7 +14,11 @@ export declare const enum FileIncludeKind {
     LibFile = 5,
     AutomaticTypeDirectiveFile = 6
 }
-/** One reason a file is in the program. */
+/**
+ * One reason a file is in the program. Reasons are immutable, so the program's loader takes the
+ * reasons a parse thread found as they are; what they compute for a program is kept by its
+ * IncludeProcessor (`ReasonCache`).
+ */
 export declare class FileIncludeReason {
     readonly kind: FileIncludeKind;
     /** The referencing file's path, for references from a file. */
@@ -26,10 +30,6 @@ export declare class FileIncludeReason {
     /** The `types` entry, for automatic type directives. */
     readonly typeReference: string;
     readonly packageId: PackageId | undefined;
-    private relativeDiagnostic;
-    private absoluteDiagnostic;
-    private location;
-    private relatedInfo;
     private constructor();
     static rootFile(index: number): FileIncludeReason;
     /** A `lib` entry, or the default library with `index` -1. */
@@ -37,7 +37,7 @@ export declare class FileIncludeReason {
     static automaticTypeDirective(typeReference: string, packageId: PackageId | undefined): FileIncludeReason;
     /** An import (`index` into the file's imports and module augmentations, -1 if `synthetic`) or a `///` reference. */
     static reference(kind: FileIncludeKind, file: string, index: number, synthetic: StringLiteral | undefined): FileIncludeReason;
-    /** The same reason without what it has computed (a parse thread's reasons are immutable). */
+    /** The same reason as a new object (`IncludeProcessor.copy`). */
     copy(): FileIncludeReason;
     isReferencedFile(): boolean;
     getReferencedLocation(program: Program): ReferenceFileLocation;
@@ -84,20 +84,46 @@ export declare class ProcessingDiagnostic {
     static explainingFileInclude(file: string, reason: FileIncludeReason | undefined, message: DiagnosticMessage, args: readonly string[]): ProcessingDiagnostic;
     /** The same diagnostic with a copy of its reason (`FileIncludeReason.copy`). */
     copy(): ProcessingDiagnostic;
+    /** This diagnostic with `renew(reason)` for its reason; itself when that is its reason. */
+    withReason(renew: (reason: FileIncludeReason) => FileIncludeReason): ProcessingDiagnostic;
     toDiagnostic(program: Program): Diagnostic;
     private explainFile;
 }
 /** Include reasons of every file and the diagnostics found while loading them. */
+/** What a reason computed for the program of an IncludeProcessor. */
+declare class ReasonCache {
+    relativeDiagnostic: Diagnostic | undefined;
+    absoluteDiagnostic: Diagnostic | undefined;
+    location: ReferenceFileLocation | undefined;
+    relatedInfo: Diagnostic | null | undefined;
+}
 export declare class IncludeProcessor {
     readonly fileIncludeReasons: Map<string, FileIncludeReason[]>;
     readonly processingDiagnostics: ProcessingDiagnostic[];
     private computed;
+    /** What each reason computed for this processor's program, once it computed something. */
+    private readonly reasonCaches;
     private compilerOptionsObject;
     private compilerOptionsComputed;
     private readonly redirectAndFileFormat;
+    /** The number of processing diagnostics when the program was created (`noteProgramCreated`). */
+    private createdCount;
     constructor(fileIncludeReasons?: Map<string, FileIncludeReason[]>, processingDiagnostics?: ProcessingDiagnostic[]);
-    /** A processor with these reasons and processing diagnostics, whose diagnostics are computed for another program. */
-    copy(): IncludeProcessor;
+    /** What `reason` computed for this processor's program, if anything. */
+    cacheOf(reason: FileIncludeReason): ReasonCache | undefined;
+    /** The cache of `reason`, created if needed. */
+    newCacheOf(reason: FileIncludeReason): ReasonCache;
+    /**
+     * A processor with these reasons and the processing diagnostics its program was created with, whose diagnostics are
+     * computed for another program. Computing the common source directory later adds diagnostics that the program
+     * does not report (`Program.commonSourceDirectory`), and those of a program shared with checker threads are
+     * immutable, so the copy has its own list. The reasons written in `replaced`, the path of the file
+     * `Program.updateFile` swaps in, are new: a reason keeps where its file writes it, which the new text may move. Each
+     * is copied once, so a diagnostic and the file's reasons still share it.
+     */
+    copy(replaced?: string): IncludeProcessor;
+    /** The program is created: the processing diagnostics so far are those a copy takes. */
+    noteProgramCreated(): void;
     reasonsOf(path: string): readonly FileIncludeReason[];
     addReason(path: string, reason: FileIncludeReason): void;
     addProcessingDiagnostic(diagnostic: ProcessingDiagnostic): void;
@@ -115,3 +141,4 @@ export declare class IncludeProcessor {
      */
     explainRedirectAndImpliedFormat(program: Program, path: string, relative: boolean): readonly Diagnostic[];
 }
+export {};

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

@@ -10,7 +10,11 @@ import { isExternalOrCommonJSModule, libNames, scriptTargetName } from './progra
 import { skipTrivia } from './scanner.js';
 import { getSpellingSuggestion } from './spelling.js';
 import { diagnosticAtNode, findArrayElement, findPropertyAssignment, findTsConfigArrayElement, getTsConfigObjectLiteral, } from './tsconfig.js';
-/** One reason a file is in the program. */
+/**
+ * One reason a file is in the program. Reasons are immutable, so the program's loader takes the
+ * reasons a parse thread found as they are; what they compute for a program is kept by its
+ * IncludeProcessor (`ReasonCache`).
+ */
 export class FileIncludeReason {
     kind;
     file;
@@ -18,10 +22,6 @@ export class FileIncludeReason {
     synthetic;
     typeReference;
     packageId;
-    relativeDiagnostic = undefined;
-    absoluteDiagnostic = undefined;
-    location = undefined;
-    relatedInfo = undefined;
     constructor(kind, 
     /** The referencing file's path, for references from a file. */
     file, 
@@ -52,7 +52,7 @@ export class FileIncludeReason {
     static reference(kind, file, index, synthetic) {
         return new FileIncludeReason(kind, file, index, synthetic, '', undefined);
     }
-    /** The same reason without what it has computed (a parse thread's reasons are immutable). */
+    /** The same reason as a new object (`IncludeProcessor.copy`). */
     copy() {
         return new FileIncludeReason(this.kind, this.file, this.index, this.synthetic, this.typeReference, this.packageId);
     }
@@ -60,8 +60,9 @@ export class FileIncludeReason {
         return this.kind <= 3 /* FileIncludeKind.LibReferenceDirective */;
     }
     getReferencedLocation(program) {
-        if (this.location !== undefined)
-            return this.location;
+        const cache = program.includeProcessor.cacheOf(this);
+        if (cache !== undefined && cache.location !== undefined)
+            return cache.location;
         const file = program.getSourceFileByPath(this.file);
         if (file === undefined)
             throw new Error('referencing file is not in the program');
@@ -101,21 +102,23 @@ export class FileIncludeReason {
                 location = new ReferenceFileLocation(file, undefined, file.libReferenceDirectives[this.index], undefined, false);
         }
         if (!program.isShared())
-            this.location = location;
+            program.includeProcessor.newCacheOf(this).location = location;
         return location;
     }
     /** The reason as a message, with file names relative to the current directory if `relative`. */
     toDiagnostic(program, relative) {
-        const cached = relative ? this.relativeDiagnostic : this.absoluteDiagnostic;
+        const cache = program.includeProcessor.cacheOf(this);
+        const cached = cache === undefined ? undefined : relative ? cache.relativeDiagnostic : cache.absoluteDiagnostic;
         if (cached !== undefined)
             return cached;
         const diagnostic = this.computeDiagnostic(program, relative);
         if (program.isShared())
             return diagnostic;
+        const own = program.includeProcessor.newCacheOf(this);
         if (relative)
-            this.relativeDiagnostic = diagnostic;
+            own.relativeDiagnostic = diagnostic;
         else
-            this.absoluteDiagnostic = diagnostic;
+            own.absoluteDiagnostic = diagnostic;
         return diagnostic;
     }
     computeDiagnostic(program, relative) {
@@ -194,11 +197,12 @@ export class FileIncludeReason {
     }
     /** Where in the config or a file this reason is written, as related information; `undefined` if nowhere. */
     toRelatedInfo(program) {
-        if (this.relatedInfo !== undefined)
-            return this.relatedInfo ?? undefined;
+        const cache = program.includeProcessor.cacheOf(this);
+        if (cache !== undefined && cache.relatedInfo !== undefined)
+            return cache.relatedInfo ?? undefined;
         const info = this.computeRelatedInfo(program);
         if (!program.isShared())
-            this.relatedInfo = info ?? null;
+            program.includeProcessor.newCacheOf(this).relatedInfo = info ?? null;
         return info;
     }
     computeRelatedInfo(program) {
@@ -330,6 +334,13 @@ export class ProcessingDiagnostic {
     copy() {
         return new ProcessingDiagnostic(this.kind, this.file, this.reason?.copy(), this.message, this.args);
     }
+    /** This diagnostic with `renew(reason)` for its reason; itself when that is its reason. */
+    withReason(renew) {
+        const reason = this.reason === undefined ? undefined : renew(this.reason);
+        return reason === this.reason
+            ? this
+            : new ProcessingDiagnostic(this.kind, this.file, reason, this.message, this.args);
+    }
     toDiagnostic(program) {
         const reason = this.reason;
         if (this.kind === 0 /* ProcessingDiagnosticKind.UnknownReference */ && reason !== undefined) {
@@ -414,20 +425,72 @@ function stripLibAffixes(name) {
     return result;
 }
 /** Include reasons of every file and the diagnostics found while loading them. */
+/** What a reason computed for the program of an IncludeProcessor. */
+class ReasonCache {
+    relativeDiagnostic = undefined;
+    absoluteDiagnostic = undefined;
+    location = undefined;
+    relatedInfo = undefined;
+}
 export class IncludeProcessor {
     fileIncludeReasons;
     processingDiagnostics;
     computed = undefined;
+    /** What each reason computed for this processor's program, once it computed something. */
+    reasonCaches = new Map();
     compilerOptionsObject = undefined;
     compilerOptionsComputed = false;
     redirectAndFileFormat = new Map();
+    /** The number of processing diagnostics when the program was created (`noteProgramCreated`). */
+    createdCount = undefined;
     constructor(fileIncludeReasons = new Map(), processingDiagnostics = []) {
         this.fileIncludeReasons = fileIncludeReasons;
         this.processingDiagnostics = processingDiagnostics;
     }
-    /** A processor with these reasons and processing diagnostics, whose diagnostics are computed for another program. */
-    copy() {
-        return new IncludeProcessor(this.fileIncludeReasons, this.processingDiagnostics);
+    /** What `reason` computed for this processor's program, if anything. */
+    cacheOf(reason) {
+        return this.reasonCaches.get(reason);
+    }
+    /** The cache of `reason`, created if needed. */
+    newCacheOf(reason) {
+        let cache = this.reasonCaches.get(reason);
+        if (cache === undefined) {
+            cache = new ReasonCache();
+            this.reasonCaches.set(reason, cache);
+        }
+        return cache;
+    }
+    /**
+     * A processor with these reasons and the processing diagnostics its program was created with, whose diagnostics are
+     * computed for another program. Computing the common source directory later adds diagnostics that the program
+     * does not report (`Program.commonSourceDirectory`), and those of a program shared with checker threads are
+     * immutable, so the copy has its own list. The reasons written in `replaced`, the path of the file
+     * `Program.updateFile` swaps in, are new: a reason keeps where its file writes it, which the new text may move. Each
+     * is copied once, so a diagnostic and the file's reasons still share it.
+     */
+    copy(replaced) {
+        const created = this.processingDiagnostics.slice(0, this.createdCount ?? this.processingDiagnostics.length);
+        if (replaced === undefined)
+            return new IncludeProcessor(this.fileIncludeReasons, created);
+        const copies = new Map();
+        const renew = (reason) => {
+            if (reason.file !== replaced)
+                return reason;
+            let copy = copies.get(reason);
+            if (copy === undefined) {
+                copy = reason.copy();
+                copies.set(reason, copy);
+            }
+            return copy;
+        };
+        const reasons = new Map();
+        for (const [path, list] of this.fileIncludeReasons)
+            reasons.set(path, list.some((reason) => reason.file === replaced) ? list.map(renew) : list);
+        return new IncludeProcessor(reasons, created.map((diagnostic) => diagnostic.withReason(renew)));
+    }
+    /** The program is created: the processing diagnostics so far are those a copy takes. */
+    noteProgramCreated() {
+        this.createdCount = this.processingDiagnostics.length;
     }
     reasonsOf(path) {
         return this.fileIncludeReasons.get(path) ?? [];

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

@@ -86,7 +86,7 @@ export declare class LoadedReference {
  * What a parse thread's FileLoader found loading a file it prepared (parallel-parse.ts): the same
  * as the program's FileLoader finds, since both load with the same options and file system. The
  * program's FileLoader takes it instead of resolving the file's references, imports and type
- * directives again. Published with the file, so the reasons are copied when taken.
+ * directives again, and takes its reasons as they are (they are immutable).
  */
 export declare class LoadedFile {
     readonly file: SourceFile;
@@ -200,6 +200,10 @@ export declare class FileLoader {
     private rootFilesAdded;
     /** The sub-tasks of prepared files, by file name, built ahead by `takeAhead`. */
     private readonly subTasksAhead;
+    /** Whether the work of the root tasks is queued (`startRootTasks`). */
+    private rootTasksStarted;
+    /** Set while `walkAhead` runs: the walk stops at work that would parse a file not prepared yet. */
+    private walkingAhead;
     /**
      * Whether a file that parse threads prepared is loaded from what its thread found (its metadata
      * and resolutions). If not, only the parsed and bound file is taken, and this loader looks up the
@@ -215,12 +219,30 @@ export declare class FileLoader {
      * task is added.
      */
     addRootFiles(count: number): boolean;
+    /** Builds ahead what loading takes from each of `files` (`takeLoadedFile`). */
+    private takeAhead;
     /**
-     * Builds ahead what loading takes from each of `files` (`takeLoadedFile`): the main thread does
-     * this while parse threads load more files (parallel-parse.ts).
+     * Loads what it can while parse threads load more files (parallel-parse.ts), the main thread's work
+     * for each batch they return: builds ahead what loading takes from its `files` (`takeAhead`), and once
+     * every root file's task is added, runs the walk `load` would run, in the same order, up to work that
+     * would parse a file the threads have not prepared yet. A later batch, or `load`, goes on from there.
+     * The order decides the program where a file is reached at several depths (the depth it is first
+     * loaded at decides the depths of the files it adds), so the walk keeps it.
      */
-    takeAhead(files: readonly PreparedFile[]): void;
+    walkAhead(files: readonly PreparedFile[]): void;
     load(): ProcessedFiles;
+    /** Adds the tasks of the libraries and of the automatic type directives, after those of the root files. */
+    private addLastRootTasks;
+    /** Adds the last root tasks and queues the work of every root task, once every root file's task is added. */
+    private startRootTasks;
+    private walk;
+    /**
+     * Drops the tasks once the program has its files, so that whatever holds the loader after loading
+     * (a parse session's callbacks) no longer keeps every file's task, sub-task list and resolution
+     * traces. Freeing them takes a while on large programs, so the drivers call this once checking
+     * has started (`releaseLater`).
+     */
+    release(): void;
     /**
      * Parse threads (parallel-parse.ts): loads one file as `load` would, parsing it through
      * `host.getSourceFile`, and adds the files it references, imports and type directives add to `out`
@@ -242,6 +264,11 @@ export declare class FileLoader {
     private libFilePriority;
     private start;
     private run;
+    /**
+     * Whether running the work of `task` (of `data`'s path) may parse a file that parse threads have not
+     * prepared yet: a task of the path not loaded yet, or `task`, a new casing.
+     */
+    private parsesUnprepared;
     private loadTask;
     /** Loads `task` from what a parse thread found loading the same file (`LoadedFile`). */
     private takeLoadedFile;
@@ -254,6 +281,8 @@ export declare class FileLoader {
     private resolveImportsAndModuleAugmentations;
     private collect;
 }
+/** Releases `loader` (`FileLoader.release`) on a later turn of the event loop, while checking runs. */
+export declare function releaseLater(loader: FileLoader): void;
 /**
  * The metadata of `fileName` in a program with `options`: the `type` and directory of its nearest
  * package.json (`resolver`), where they apply, and its implied module format.

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

@@ -6,7 +6,7 @@ import { FileIncludeReason, IncludeProcessor, ProcessingDiagnostic } from './fil
 import { ModuleResolutionHost, Resolver, getAutomaticTypeDirectiveNames } from './module-resolution.js';
 import { getResolutionDiagnostic, inferredTypesContainingFile, } from './module-resolution-types.js';
 import { getAllowJS, getIsolatedModules, getModuleResolutionKind, ModuleKind, ModuleResolutionKind, } from './options.js';
-import { preparedLoad, preparedPackageJsonLookups, takePreparedFile, } from './parallel-parse.js';
+import { isPrepared, preparedLoad, preparedPackageJsonLookups, takePreparedFile, } from './parallel-parse.js';
 import { parseSourceFile } from './parser.js';
 import { mark } from './timeline.js';
 import { combinePaths, fileExtensionIsOneOf, getCanonicalFileName, getDirectoryPath, getNormalizedAbsolutePath, getRootLength, hasJSFileExtension, isRootedDiskPath, normalizePath, normalizeSlashes, removeTrailingDirectorySeparator, supportedTSExtensionsWithJsonFlat, toFileNameLowerCase, toPath, } from './path.js';
@@ -132,7 +132,7 @@ export class LoadedReference {
  * What a parse thread's FileLoader found loading a file it prepared (parallel-parse.ts): the same
  * as the program's FileLoader finds, since both load with the same options and file system. The
  * program's FileLoader takes it instead of resolving the file's references, imports and type
- * directives again. Published with the file, so the reasons are copied when taken.
+ * directives again, and takes its reasons as they are (they are immutable).
  */
 export class LoadedFile {
     file;
@@ -358,7 +358,7 @@ 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(), 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);
 }
 /** Whether `file` imports the `importHelpers` module (tslib) under `options`. */
 export function needsImportHelpersImportSpecifier(file, options) {
@@ -456,6 +456,10 @@ export class FileLoader {
     rootFilesAdded = 0;
     /** The sub-tasks of prepared files, by file name, built ahead by `takeAhead`. */
     subTasksAhead = new Map();
+    /** Whether the work of the root tasks is queued (`startRootTasks`). */
+    rootTasksStarted = false;
+    /** Set while `walkAhead` runs: the walk stops at work that would parse a file not prepared yet. */
+    walkingAhead = false;
     /**
      * Whether a file that parse threads prepared is loaded from what its thread found (its metadata
      * and resolutions). If not, only the parsed and bound file is taken, and this loader looks up the
@@ -498,10 +502,7 @@ export class FileLoader {
         this.rootFilesAdded = end;
         return end === rootFiles.length;
     }
-    /**
-     * Builds ahead what loading takes from each of `files` (`takeLoadedFile`): the main thread does
-     * this while parse threads load more files (parallel-parse.ts).
-     */
+    /** Builds ahead what loading takes from each of `files` (`takeLoadedFile`). */
     takeAhead(files) {
         for (const prepared of files) {
             const loaded = prepared.loaded;
@@ -513,10 +514,39 @@ export class FileLoader {
             this.subTasksAhead.set(prepared.fileName, new SubTasksAhead(loaded, subTasks));
         }
     }
+    /**
+     * Loads what it can while parse threads load more files (parallel-parse.ts), the main thread's work
+     * for each batch they return: builds ahead what loading takes from its `files` (`takeAhead`), and once
+     * every root file's task is added, runs the walk `load` would run, in the same order, up to work that
+     * would parse a file the threads have not prepared yet. A later batch, or `load`, goes on from there.
+     * The order decides the program where a file is reached at several depths (the depth it is first
+     * loaded at decides the depths of the files it adds), so the walk keeps it.
+     */
+    walkAhead(files) {
+        this.takeAhead(files);
+        if (!this.rootTasksStarted && this.rootFilesAdded < this.config.fileNames.length)
+            return;
+        this.startRootTasks();
+        this.walkingAhead = true;
+        this.walk();
+        this.walkingAhead = false;
+    }
     load() {
-        const rootFiles = this.config.fileNames;
-        this.addRootFiles(rootFiles.length);
-        if (rootFiles.length > 0 && this.options.noLib !== true) {
+        this.addRootFiles(this.config.fileNames.length);
+        this.startRootTasks();
+        mark('loader roots added');
+        this.walk();
+        mark('loader walked');
+        const result = this.collect();
+        mark('loader collected');
+        this.mapper.loader = undefined;
+        return result;
+    }
+    /** Adds the tasks of the libraries and of the automatic type directives, after those of the root files. */
+    addLastRootTasks() {
+        if (this.config.fileNames.length === 0)
+            return;
+        if (this.options.noLib !== true) {
             const lib = this.options.lib;
             if (lib === undefined) {
                 const libFile = this.pathForLibFile(getDefaultLibFileName(this.options));
@@ -532,21 +562,41 @@ export class FileLoader {
                 }
             }
         }
-        if (rootFiles.length > 0) {
-            const containingDirectory = this.options.configFilePath !== undefined
-                ? getDirectoryPath(this.options.configFilePath)
-                : this.host.currentDirectory;
-            this.rootTasks.push(new ParseTask(combinePaths(containingDirectory, inferredTypesContainingFile), undefined, undefined, true, false, false, undefined));
-        }
-        mark('loader roots added');
+        const containingDirectory = this.options.configFilePath !== undefined
+            ? getDirectoryPath(this.options.configFilePath)
+            : this.host.currentDirectory;
+        this.rootTasks.push(new ParseTask(combinePaths(containingDirectory, inferredTypesContainingFile), undefined, undefined, true, false, false, undefined));
+    }
+    /** Adds the last root tasks and queues the work of every root task, once every root file's task is added. */
+    startRootTasks() {
+        if (this.rootTasksStarted)
+            return;
+        this.rootTasksStarted = true;
+        this.addLastRootTasks();
         this.start(this.rootTasks, 0);
-        for (let work = this.work.pop(); work !== undefined; work = this.work.pop())
+    }
+    walk() {
+        for (let work = this.work.pop(); work !== undefined; work = this.work.pop()) {
+            if (this.walkingAhead && this.parsesUnprepared(work.tasks[work.index], work.data)) {
+                this.work.push(work);
+                return;
+            }
             this.run(work);
-        mark('loader walked');
-        const result = this.collect();
-        mark('loader collected');
-        this.mapper.loader = undefined;
-        return result;
+        }
+    }
+    /**
+     * Drops the tasks once the program has its files, so that whatever holds the loader after loading
+     * (a parse session's callbacks) no longer keeps every file's task, sub-task list and resolution
+     * traces. Freeing them takes a while on large programs, so the drivers call this once checking
+     * has started (`releaseLater`).
+     */
+    release() {
+        this.rootTasks.length = 0;
+        this.taskDataByPath.clear();
+        this.work.length = 0;
+        this.subTasksAhead.clear();
+        this.referenceTasks.clear();
+        this.paths.clear();
     }
     /**
      * Parse threads (parallel-parse.ts): loads one file as `load` would, parsing it through
@@ -842,6 +892,18 @@ export class FileLoader {
             }
         }
     }
+    /**
+     * Whether running the work of `task` (of `data`'s path) may parse a file that parse threads have not
+     * prepared yet: a task of the path not loaded yet, or `task`, a new casing.
+     */
+    parsesUnprepared(task, data) {
+        if (!data.tasks.has(task.normalizedFilePath) && !isPrepared(task.normalizedFilePath))
+            return true;
+        for (const other of data.tasks.values())
+            if (!other.loaded && !other.isForAutomaticTypeDirective && !isPrepared(other.normalizedFilePath))
+                return true;
+        return false;
+    }
     loadTask(task) {
         task.loaded = true;
         if (task.isForAutomaticTypeDirective) {
@@ -924,7 +986,7 @@ export class FileLoader {
         const subTasks = [];
         for (const reference of loaded.references) {
             const libFile = reference.libName !== '' ? this.pathForLibFile(reference.libName) : undefined;
-            subTasks.push(new ParseTask(reference.normalizedFilePath, libFile, reference.reason.copy(), false, reference.increaseDepth, reference.elideOnDepth, reference.packageId));
+            subTasks.push(new ParseTask(reference.normalizedFilePath, libFile, reference.reason, false, reference.increaseDepth, reference.elideOnDepth, reference.packageId));
         }
         return subTasks;
     }
@@ -1194,6 +1256,10 @@ export class FileLoader {
     }
 }
 const noPackageJsonLookups = [];
+/** Releases `loader` (`FileLoader.release`) on a later turn of the event loop, while checking runs. */
+export function releaseLater(loader) {
+    setImmediate(() => loader.release());
+}
 function addIncludeReason(processor, task, reason) {
     const redirected = task.redirectedParseTask;
     if (redirected !== undefined)