tsc-ts 0.0.9 → 0.1.0

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

@@ -2,15 +2,17 @@
  * Finds every file of a program: root files, libraries, references, imports and type directives, in tsgo's order.
  */
 import { ImportDeclaration, ParseOptions, StringLiteral, getText, } from './ast.js';
+import { messageWithArgs } from './diagnostics.js';
 import { FileIncludeReason, IncludeProcessor, ProcessingDiagnostic } from './file-include.js';
 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 { isPrepared, preparedLoad, preparedPackageJsonLookups, takePreparedFile, } from './parallel-parse.js';
-import { parseSourceFile } from './parser.js';
+import { parseSourceFile, getScriptKindFromFileName } 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';
+import { combinePaths, fileExtensionIsOneOf, getCanonicalFileName, getDirectoryPath, getNormalizedAbsolutePath, getRootLength, hasJSFileExtension, isRootedDiskPath, normalizePath, normalizeSlashes, removeTrailingDirectorySeparator, supportedTSExtensionsWithJsonFlat, toFileNameLowerCase, toPath, isNetworkPath, } from './path.js';
 import { getDefaultLibFileName, getDefaultResolutionModeForFile, getExternalModuleIndicatorOptions, getImpliedNodeFormatForFile, getJSXImplicitImportBase, getJSXRuntimeImport, getLibFileName, getModeForUsageLocation, isExternalModule, isSourceFileJS, libFileMetadata, libNames, SourceFileMetadata, } from './program-utilities.js';
+import { isSourcePhaseImport } from './ast-utilities.js';
 import { hasExtension } from './vfs-match.js';
 import { ConfigParser, flattenExtensions, getSupportedExtensions, getSupportedExtensionsWithJsonIfResolveJsonModule, } from './tsconfig.js';
 /** Files and services the compiler reads through. */
@@ -58,7 +60,10 @@ export class CompilerHost extends ModuleResolutionHost {
         const text = this.fs.readFile(fileName);
         if (text === undefined)
             return undefined;
-        return parseSourceFile(fileName, text, new ParseOptions(path, 0 /* ScriptKind.Unknown */, externalModuleIndicatorOptions));
+        // A file without a known extension (with allowNonTsExtensions) parses as TypeScript.
+        const kind = getScriptKindFromFileName(fileName);
+        const scriptKind = kind === 0 /* ScriptKind.Unknown */ ? 3 /* ScriptKind.TS */ : kind;
+        return parseSourceFile(fileName, text, new ParseOptions(path, scriptKind, externalModuleIndicatorOptions));
     }
     /** The config of a referenced project, or `undefined` if it can't be read. */
     getResolvedProjectReference(fileName) {
@@ -187,6 +192,8 @@ class ParseTask {
     subTasks = undefined;
     loaded = false;
     startedSubTasks = false;
+    /** A root file name that resolved to no supported file: the task only carries its processing diagnostic. */
+    failedLookup = false;
     metadata = libFileMetadata;
     resolutionsInFile = undefined;
     resolutionsTrace = undefined;
@@ -197,6 +204,10 @@ class ParseTask {
     jsxRuntimeImport = undefined;
     /** The task of the same file name that was loaded instead of this one. */
     loadedTask = undefined;
+    /** The index in `FileLoader.taskData` of the tasks of this task's path, once known; -1 before. */
+    dataIndex = -1;
+    /** 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) {
@@ -207,6 +218,8 @@ 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));
@@ -223,15 +236,43 @@ class ParseTask {
         return trace ? (this.typeResolutionsTrace ??= []) : undefined;
     }
 }
+const noData = [];
+/** The resolution of a module the importing file declares itself: none. */
+const locallyDeclaredModule = {
+    resolvedFileName: '',
+    originalPath: '',
+    extension: '',
+    resolvedUsingTsExtension: false,
+    packageId: undefined,
+    isExternalLibraryImport: false,
+    alternateResult: '',
+    resolutionDiagnostics: [],
+};
 /** The tasks of one path, by file name casing. */
 class ParseTaskData {
     tasks = new Map();
+    /** Whether a task of the path is queued (`start`). */
+    queued = false;
+    /** The path's first queued task, the first of `tasks`. */
+    first = undefined;
+    /**
+     * Whether every task of `tasks` is loaded (`run`): then more work of the path does nothing unless it
+     * reaches the path at a lower depth.
+     */
+    settled = false;
     lowestDepth = Number.MAX_SAFE_INTEGER;
     startedSubTasks = false;
     packageId = undefined;
-    constructor(task) {
-        this.tasks.set(task.normalizedFilePath, task);
-    }
+    /** 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;
+    /** The file name `collect` reached the path by first, once it did. */
+    collectedName = undefined;
+    /** The path's include reasons, once `collect` found one: the list in `IncludeProcessor.fileIncludeReasons`. */
+    reasons = undefined;
 }
 /** Pending processing of `tasks[index]`. */
 class ParseWork {
@@ -340,6 +381,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, 
@@ -351,7 +393,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;
@@ -369,6 +416,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`. */
@@ -377,7 +425,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) {
@@ -387,7 +437,7 @@ export function needsImportHelpersImportSpecifier(file, options) {
 }
 /** The module `file` imports the JSX runtime from under `options`, or '' if it imports none. */
 export function jsxRuntimeImportOf(file, options) {
-    if (file.scriptKind !== 2 /* ScriptKind.JSX */ && file.scriptKind !== 4 /* ScriptKind.TSX */)
+    if (!isSourceFileJS(file) && file.scriptKind !== 4 /* ScriptKind.TSX */)
         return '';
     return getJSXRuntimeImport(getJSXImplicitImportBase(options, file), options);
 }
@@ -461,6 +511,9 @@ export class FileLoader {
     supportedExtensionsWithJson;
     maxNodeModuleJsDepth;
     rootTasks = [];
+    /** The tasks of each path, created when a task of the path is first queued or built ahead. */
+    taskData = [];
+    /** The index in `taskData` of each path's tasks. */
     taskDataByPath = new Map();
     /** Work queued by `start`, run last-in first-out like tsgo's single-threaded work group. */
     work = [];
@@ -528,8 +581,11 @@ export class FileLoader {
             if (loaded === undefined)
                 continue;
             const subTasks = this.subTasksOf(loaded);
-            for (const task of subTasks)
+            // Their paths and tasks, found here while threads parse rather than when the walk reaches them.
+            for (const task of subTasks) {
                 task.path = this.toPath(task.normalizedFilePath);
+                task.dataIndex = this.dataIndexOf(task.path);
+            }
             this.subTasksAhead.set(prepared.fileName, new SubTasksAhead(loaded, subTasks));
         }
     }
@@ -596,7 +652,7 @@ export class FileLoader {
     }
     walk() {
         for (let work = this.work.pop(); work !== undefined; work = this.work.pop()) {
-            if (this.walkingAhead && this.parsesUnprepared(work.tasks[work.index], work.data)) {
+            if (this.walkingAhead && !this.elides(work) && this.parsesUnprepared(work.tasks[work.index], work.data)) {
                 this.work.push(work);
                 return;
             }
@@ -611,6 +667,7 @@ export class FileLoader {
      */
     release() {
         this.rootTasks.length = 0;
+        this.taskData.length = 0;
         this.taskDataByPath.clear();
         this.work.length = 0;
         this.subTasksAhead.clear();
@@ -756,6 +813,7 @@ export class FileLoader {
             return;
         }
         const task = new ParseTask(absolute, undefined, reason, false, false, false, undefined);
+        task.failedLookup = true;
         task.addProcessingDiagnostic(ProcessingDiagnostic.explainingFileInclude('', reason, resolved.message, resolved.args));
         this.rootTasks.push(task);
     }
@@ -773,17 +831,19 @@ export class FileLoader {
     getSourceFileFromReference(fileName, referenceText, containingFile, reason) {
         const allowNonTsExtensions = this.options.allowNonTsExtensions === true;
         const diagnosticFileName = normalizeSlashes(referenceText);
+        if (isNetworkPath(fileName))
+            return new ReferenceDiagnostic(1195 /* Diagnostics.Network_path_0_is_not_supported */, [diagnosticFileName]);
         const fs = this.host.fs;
         if (hasExtension(fileName)) {
             const canonicalFileName = getCanonicalFileName(fileName, fs.useCaseSensitiveFileNames);
             if (!allowNonTsExtensions && !this.isSupportedExtension(canonicalFileName)) {
                 if (hasJSFileExtension(canonicalFileName)) {
-                    return new ReferenceDiagnostic(1519 /* Diagnostics.File_0_is_a_JavaScript_file_Did_you_mean_to_enable_the_allowJs_option */, [diagnosticFileName]);
+                    return new ReferenceDiagnostic(1530 /* Diagnostics.File_0_is_a_JavaScript_file_Did_you_mean_to_enable_the_allowJs_option */, [diagnosticFileName]);
                 }
-                return new ReferenceDiagnostic(1230 /* Diagnostics.File_0_has_an_unsupported_extension_The_only_supported_extensions_are_1 */, [diagnosticFileName, this.supportedExtensionsList()]);
+                return new ReferenceDiagnostic(1241 /* Diagnostics.File_0_has_an_unsupported_extension_The_only_supported_extensions_are_1 */, [diagnosticFileName, this.supportedExtensionsList()]);
             }
             if (!fs.fileExists(fileName))
-                return new ReferenceDiagnostic(1229 /* Diagnostics.File_0_not_found */, [diagnosticFileName]);
+                return new ReferenceDiagnostic(1240 /* Diagnostics.File_0_not_found */, [diagnosticFileName]);
             if (reason.isReferencedFile() &&
                 getCanonicalFileName(containingFile, fs.useCaseSensitiveFileNames) === canonicalFileName) {
                 return new ReferenceDiagnostic(3 /* Diagnostics.A_file_cannot_have_a_reference_to_itself */, []);
@@ -793,14 +853,14 @@ export class FileLoader {
         if (allowNonTsExtensions) {
             return fs.fileExists(fileName)
                 ? fileName
-                : new ReferenceDiagnostic(1229 /* Diagnostics.File_0_not_found */, [diagnosticFileName]);
+                : new ReferenceDiagnostic(1240 /* Diagnostics.File_0_not_found */, [diagnosticFileName]);
         }
         for (const extension of this.supportedExtensions[0]) {
             const candidate = fileName + extension;
             if (fs.fileExists(candidate))
                 return candidate;
         }
-        return new ReferenceDiagnostic(1383 /* Diagnostics.Could_not_resolve_the_path_0_with_the_extensions_Colon_1 */, [
+        return new ReferenceDiagnostic(1394 /* Diagnostics.Could_not_resolve_the_path_0_with_the_extensions_Colon_1 */, [
             diagnosticFileName,
             this.supportedExtensionsList(),
         ]);
@@ -856,31 +916,51 @@ export class FileLoader {
     }
     // ---- Loading
     start(tasks, depth) {
+        const taskData = this.taskData;
         for (let i = 0; i < tasks.length; i++) {
             const task = tasks[i];
-            // Sub-tasks built ahead have their paths.
-            if (task.path === '')
-                task.path = this.toPath(task.normalizedFilePath);
-            let data = this.taskDataByPath.get(task.path);
-            const loaded = data !== undefined;
-            if (data === undefined) {
-                data = new ParseTaskData(task);
-                this.taskDataByPath.set(task.path, data);
+            // Sub-tasks built ahead have their paths and tasks.
+            let k = task.dataIndex;
+            if (k < 0) {
+                if (task.path === '')
+                    task.path = this.toPath(task.normalizedFilePath);
+                k = this.dataIndexOf(task.path);
+                task.dataIndex = k;
+            }
+            const data = taskData[k];
+            const loaded = data.queued;
+            if (!loaded) {
+                data.queued = true;
+                data.first = task;
+                data.tasks.set(task.normalizedFilePath, task);
             }
             this.work.push(new ParseWork(tasks, i, data, loaded, depth));
         }
     }
+    /** The index in `taskData` of the tasks of `path`, created if needed. */
+    dataIndexOf(path) {
+        let k = this.taskDataByPath.get(path);
+        if (k === undefined) {
+            k = this.taskData.length;
+            this.taskData.push(new ParseTaskData());
+            this.taskDataByPath.set(path, k);
+        }
+        return k;
+    }
     run(work) {
         const task = work.tasks[work.index];
         const data = work.data;
         let startSubTasks = false;
         if (work.loaded) {
-            const existing = data.tasks.get(task.normalizedFilePath);
+            const name = task.normalizedFilePath;
+            const first = data.first;
+            const existing = first !== undefined && first.normalizedFilePath === name ? first : data.tasks.get(name);
             if (existing !== undefined) {
                 task.loadedTask = existing;
             }
             else {
-                data.tasks.set(task.normalizedFilePath, task);
+                data.tasks.set(name, task);
+                data.settled = false;
                 // A new casing of a file: load its references if another casing's were.
                 startSubTasks = data.startedSubTasks;
             }
@@ -888,7 +968,8 @@ export class FileLoader {
         if (data.packageId === undefined && task.packageId !== undefined)
             data.packageId = task.packageId;
         const depth = task.increaseDepth ? work.depth + 1 : work.depth;
-        if (depth < data.lowestDepth) {
+        const lowered = depth < data.lowestDepth;
+        if (lowered) {
             // Reached at a lower depth than before: load references again.
             data.lowestDepth = depth;
             startSubTasks = true;
@@ -896,6 +977,9 @@ export class FileLoader {
         }
         if (task.elideOnDepth && depth > this.maxNodeModuleJsDepth)
             return;
+        // Most work reaches a path already loaded, at no lower depth.
+        if (data.settled && !startSubTasks)
+            return;
         for (const taskByFileName of data.tasks.values()) {
             let loadSubTasks = startSubTasks;
             if (!taskByFileName.loaded) {
@@ -905,12 +989,23 @@ export class FileLoader {
                     data.startedSubTasks = true;
                 }
             }
-            if (!taskByFileName.startedSubTasks && loadSubTasks) {
+            // A lower depth restarts references already started, which may now be loaded past `maxNodeModuleJsDepth`.
+            // Every file reached from them is at least as deep, so a depth past it changes nothing they load.
+            if (loadSubTasks && ((lowered && depth <= this.maxNodeModuleJsDepth) || !taskByFileName.startedSubTasks)) {
                 taskByFileName.startedSubTasks = true;
                 if (taskByFileName.subTasks !== undefined)
                     this.start(taskByFileName.subTasks, data.lowestDepth);
             }
         }
+        data.settled = true;
+    }
+    /**
+     * Whether `run` drops `work` without loading its file: a JavaScript file past `maxNodeModuleJsDepth`,
+     * which no parse thread prepares, so the walk ahead does not wait for it.
+     */
+    elides(work) {
+        const task = work.tasks[work.index];
+        return task.elideOnDepth && (task.increaseDepth ? work.depth + 1 : work.depth) > this.maxNodeModuleJsDepth;
     }
     /**
      * Whether running the work of `task` (of `data`'s path) may parse a file that parse threads have not
@@ -930,6 +1025,8 @@ export class FileLoader {
             this.loadAutomaticTypeDirectives(task);
             return;
         }
+        if (task.failedLookup)
+            return;
         const redirect = this.mapper.getParseFileRedirect(task.path);
         if (redirect !== '') {
             const redirected = new ParseTask(normalizePath(redirect), task.libFile, task.includeReason, false, false, false, undefined);
@@ -942,8 +1039,8 @@ export class FileLoader {
             const canonicalFileName = getCanonicalFileName(task.normalizedFilePath, fs.useCaseSensitiveFileNames);
             if (!this.isSupportedExtension(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()]));
+                    ? ProcessingDiagnostic.explainingFileInclude('', task.includeReason, 1530 /* Diagnostics.File_0_is_a_JavaScript_file_Did_you_mean_to_enable_the_allowJs_option */, [task.normalizedFilePath])
+                    : ProcessingDiagnostic.explainingFileInclude('', task.includeReason, 1241 /* Diagnostics.File_0_has_an_unsupported_extension_The_only_supported_extensions_are_1 */, [task.normalizedFilePath, this.supportedExtensionsList()]));
                 return;
             }
         }
@@ -1065,7 +1162,7 @@ export class FileLoader {
                 task.addSubTask(resolved.resolvedFileName, undefined, FileIncludeReason.automaticTypeDirective(name, resolved.packageId), resolved.isExternalLibraryImport, false, resolved.packageId);
             }
             else {
-                task.addProcessingDiagnostic(ProcessingDiagnostic.explainingFileInclude('', FileIncludeReason.automaticTypeDirective(name, undefined), 821 /* Diagnostics.Cannot_find_type_definition_file_for_0 */, [name]));
+                task.addProcessingDiagnostic(ProcessingDiagnostic.explainingFileInclude('', FileIncludeReason.automaticTypeDirective(name, undefined), 828 /* Diagnostics.Cannot_find_type_definition_file_for_0 */, [name]));
             }
         }
         task.typeResolutionsInFile = resolutions;
@@ -1100,9 +1197,19 @@ export class FileLoader {
         for (let index = 0; index < moduleNames.length; index++) {
             const entry = moduleNames[index];
             const moduleName = getText(entry);
-            if (moduleName === '')
+            // A source phase import loads no module declarations.
+            if (moduleName === '' || isSourcePhaseImport(entry.parent))
                 continue;
             const mode = getModeForUsageLocation(file.fileName, task.metadata, entry, options);
+            // A module the file declares itself (`declare module "m"`) isn't resolved.
+            if (file.ambientModuleNames.includes(moduleName)) {
+                if (options.traceResolution === true)
+                    task
+                        .moduleTraces(true)
+                        .push(messageWithArgs(1319 /* Diagnostics.Module_0_was_resolved_as_locally_declared_ambient_module_in_file_1 */, moduleName, file.fileName));
+                resolutions.set(modeAwareKey(moduleName, mode), locallyDeclaredModule);
+                continue;
+            }
             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;
@@ -1153,21 +1260,30 @@ export class FileLoader {
         const redirectFilesByPath = new Map();
         const packageIdToSourceFile = new Map();
         const checkCasing = this.options.forceConsistentCasingInFileNames !== false;
-        const seen = new Map();
-        const collectFiles = (tasks) => {
+        const taskData = this.taskData;
+        // 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)
                         task = task.loadedTask;
                     if (includeReason !== undefined)
-                        addIncludeReason(includeProcessor, task, includeReason);
+                        addIncludeReason(includeProcessor, taskData, task, includeReason);
                 }
-                const data = this.taskDataByPath.get(task.path);
+                const data = task.dataIndex >= 0 ? taskData[task.dataIndex] : undefined;
+                if (added !== undefined && data !== undefined && byImport)
+                    added.push(data);
                 if (!task.loaded || data === undefined)
                     continue;
-                const checkedName = seen.get(data);
+                const checkedName = data.collectedName;
                 if (checkedName !== undefined) {
                     // The same name normalizes the same: only another spelling needs comparing.
                     if (checkCasing &&
@@ -1178,7 +1294,7 @@ export class FileLoader {
                     }
                     continue;
                 }
-                seen.set(data, task.normalizedFilePath);
+                data.collectedName = task.normalizedFilePath;
                 if (tasksSeenByNameIgnoreCase !== undefined) {
                     const lowerCasePath = toFileNameLowerCase(task.path);
                     const existing = tasksSeenByNameIgnoreCase.get(lowerCasePath);
@@ -1206,15 +1322,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);
+                    }
                 }
+                let own = undefined;
                 if (task.subTasks !== undefined && task.subTasks.length > 0)
-                    collectFiles(task.subTasks);
+                    collectFiles(task.subTasks, (own = []));
                 const redirected = task.redirectedParseTask;
                 if (redirected !== undefined) {
                     outputFileToProjectReferenceSource.set(redirected.path, task.normalizedFilePath);
@@ -1226,20 +1346,26 @@ export class FileLoader {
                         includeProcessor.addProcessingDiagnostic(diagnostic);
                     continue;
                 }
-                const path = task.path;
                 for (const diagnostic of task.processingDiagnostics ?? noProcessingDiagnostics)
                     includeProcessor.addProcessingDiagnostic(diagnostic);
                 if (file === undefined) {
                     missingFiles.push(task.normalizedFilePath);
                     continue;
                 }
+                // The program's maps of the file are keyed by the file's own path: lookups by `file.path` then find
+                // the same string, also for a file a parse thread created, whose path is another string than the task's.
+                const path = file.path === task.path ? file.path : task.path;
                 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);
@@ -1253,7 +1379,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));
@@ -1261,6 +1387,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);
@@ -1272,7 +1417,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 = [];
@@ -1280,12 +1425,20 @@ const noPackageJsonLookups = [];
 export function releaseLater(loader) {
     setImmediate(() => loader.release());
 }
-function addIncludeReason(processor, task, reason) {
+function addIncludeReason(processor, taskData, task, reason) {
     const redirected = task.redirectedParseTask;
     if (redirected !== undefined)
-        addIncludeReason(processor, redirected, reason);
-    else if (task.loaded)
-        processor.addReason(task.path, reason);
+        addIncludeReason(processor, taskData, redirected, reason);
+    else if (task.loaded) {
+        // The path's list, without looking the path up for each reference to the file.
+        const data = task.dataIndex >= 0 ? taskData[task.dataIndex] : undefined;
+        if (data === undefined)
+            processor.addReason(task.path, reason);
+        else if (data.reasons !== undefined)
+            data.reasons.push(reason);
+        else
+            data.reasons = processor.addReason(task.path, reason);
+    }
 }
 function createProjectReferenceTasks(paths) {
     const tasks = [];
@@ -1302,7 +1455,7 @@ function withoutRoot(path) {
 /** A specifier of an import the compiler adds, such as `tslib` for `importHelpers`. */
 function createSyntheticImport(text, file) {
     const specifier = new StringLiteral(text, 0 /* TokenFlags.None */);
-    const declaration = new ImportDeclaration(273 /* SyntaxKind.ImportDeclaration */, undefined, undefined, specifier, undefined);
+    const declaration = new ImportDeclaration(274 /* SyntaxKind.ImportDeclaration */, undefined, undefined, specifier, undefined);
     specifier.parent = declaration;
     declaration.parent = file;
     return specifier;

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

@@ -38,6 +38,8 @@ export declare class UniqueLiteralMapper extends TypeMapper {
 export declare function combineTypeMappers(c: Checker, m1: TypeMapper | undefined, m2: TypeMapper): TypeMapper;
 export declare function instantiateType(c: Checker, type: Type, mapper: TypeMapper | undefined): Type;
 export declare function instantiateTypeWithAlias(c: Checker, type: Type, mapper: TypeMapper | undefined, alias: TypeAlias | undefined): Type;
+/** `'a', 'b', 'c'`. */
+export declare function quotedAndCommaSeparated(items: readonly string[]): string;
 /** Whether `type` could reference a type parameter we infer for. Cached on the type. */
 export declare function couldContainTypeVariables(c: Checker, type: Type): boolean;
 /** Whether `node` has a reference to `tp` (or one that may be to it, such as a type query). */
@@ -65,6 +67,11 @@ export declare function instantiateSymbol(c: Checker, symbol: Symbol, mapper: Ty
  * is resolved yet, so lazily instantiated members record it when tsgo would instantiate them.
  */
 export declare function keepsSymbolUnderInstantiation(c: Checker, symbol: Symbol, mapper: TypeMapper): boolean;
+/**
+ * Whether the resolved type of `symbol` (and its write type) can't change under instantiation, so that
+ * `instantiateSymbol` keeps it whatever the mapper. Once true, it stays true: types are resolved once.
+ */
+export declare function keepsSymbolTypeUnderInstantiation(c: Checker, symbol: Symbol): boolean;
 /** The instantiated copy of `symbol` that `instantiateSymbol` creates when it doesn't keep it. */
 export declare function newInstantiatedSymbol(c: Checker, symbol: Symbol, mapper: TypeMapper): Symbol;
 /** Conservatively, whether a parameter or member's type can't reference `this`. */