tsc-ts 0.0.10 → 0.1.0

package/src/compiler/emitter.ts

@@ -1,7 +1,7 @@
 // Emits JavaScript and declarations for source files: runs the transforms, prints, and writes
 // the output, source map and `//# sourceMappingURL` comment.
 import { ScriptKind, type SourceFile } from './ast.js';
-import { compareDiagnostics, type Diagnostic } from './diagnostics.js';
+import { compareDiagnostics, equalDiagnostics, type Diagnostic } from './diagnostics.js';
 import { type CompilerOptions, JsxEmit, NewLineKind, getEmitScriptTarget, getIsolatedModules } from './options.js';
 import { LanguageVariant } from './types.js';
 import { type OutputPathsHost, getOutputPathsFor } from './output-paths.js';
@@ -33,7 +33,7 @@ import { RuntimeSyntax } from './transformers/runtime-syntax.js';
 import { ConstEnumInliner } from './transformers/const-enum-inliner.js';
 import { addDownlevelTransformers } from './transformers/downlevel.js';
 import { JsxTransformer } from './transformers/jsx.js';
-import { SyntaxFacts } from './transformers/syntax-facts.js';
+import { SubtreeFacts, SyntaxFacts } from './transformers/syntax-facts.js';
 import { LegacyDecorators } from './transformers/legacy-decorators.js';
 import { DecoratorMetadata } from './transformers/decorator-metadata.js';
 
@@ -143,6 +143,12 @@ export const enum EmitOnly {
    * signature of incremental builds; it is written with its errors and without a map.
    */
   ForcedDts,
+  /**
+   * The declaration file of a file whose JavaScript this build emits in a separate request, such as on another
+   * thread. tsgo emits both with one emit context, so the emit flags its JavaScript transforms set on the file's
+   * own nodes also apply to its declarations; this replays those transforms first.
+   */
+  DtsAfterJs,
 }
 
 export function emitFiles(host: EmitHost, files: readonly SourceFile[], emitOnly: EmitOnly = EmitOnly.All): EmitResult {
@@ -157,21 +163,44 @@ export function emitFiles(host: EmitHost, files: readonly SourceFile[], emitOnly
     const file = files[i];
     if (!sourceFileMayBeEmitted(file, options) || host.isSourceFileFromExternalLibrary(file)) continue;
     const paths = getOutputPathsFor(file.fileName, file.scriptKind === ScriptKind.JSON, options, host, forced);
+    // As in tsgo, a file's JavaScript and declarations share one emit context: emit flags that JavaScript
+    // transforms set on the file's own nodes, such as a decorated parameter's name, also apply to its declarations.
+    const context = new EmitContext();
     if (paths.jsFilePath !== '' && (emitOnly === EmitOnly.All || emitOnly === EmitOnly.Js)) {
       if (host.isEmitBlocked(paths.jsFilePath)) result.emitSkipped = true;
-      else emitJSFile(host, file, paths.jsFilePath, paths.sourceMapFilePath, result);
+      else emitJSFile(host, context, file, paths.jsFilePath, paths.sourceMapFilePath, result);
     }
     if (paths.declarationFilePath !== '' && emitOnly !== EmitOnly.Js) {
       if (!forced && host.isEmitBlocked(paths.declarationFilePath)) result.emitSkipped = true;
-      else emitDeclarationFile(host, file, paths.declarationFilePath, paths.declarationMapPath, result, forced);
+      else {
+        if (emitOnly === EmitOnly.DtsAfterJs && paths.jsFilePath !== '') replayScriptTransforms(host, context, file);
+        emitDeclarationFile(host, context, file, paths.declarationFilePath, paths.declarationMapPath, result, forced);
+      }
     }
   }
   return result;
 }
 
+/**
+ * Runs the JavaScript transforms of `file` in `context` without printing, for the emit flags they set on the
+ * file's own nodes. Only the decorator transforms set any that declaration emit prints (on decorated parameters'
+ * names), so files without decorators are skipped.
+ */
+function replayScriptTransforms(host: EmitHost, context: EmitContext, file: SourceFile): void {
+  if (!new SyntaxFacts().has(file, SubtreeFacts.ContainsDecorators)) return;
+  let transformed = file;
+  const transformers = getScriptTransformers(host, context, file);
+  for (let i = 0; i < transformers.length; i++) {
+    const transformer = transformers[i];
+    if (transformer.unsupported !== '') return;
+    transformed = transformer.transformSourceFile(transformed);
+  }
+}
+
 /** Emits a declaration file; the host's resolver must be a `DeclarationEmitResolver`. */
 function emitDeclarationFile(
   host: EmitHost,
+  context: EmitContext,
   file: SourceFile,
   declarationFilePath: string,
   declarationMapPath: string,
@@ -184,7 +213,6 @@ function emitDeclarationFile(
     return false;
   }
   const options = host.options;
-  const context = new EmitContext();
   const transformer = new DeclarationTransformer(context, host, options, resolver, declarationFilePath);
   const transformed = transformer.transformSourceFile(file);
   result.declarationTransformed = true;
@@ -214,11 +242,32 @@ function emitDeclarationFile(
     emitSourceMaps,
     false,
     result,
-    // Sorted, as tsgo's emitter diagnostics are; the order is part of the file's signature in build info.
-    diagnostics.length > 1 ? diagnostics.toSorted(compareDiagnostics) : diagnostics,
+    emitterDiagnostics(diagnostics),
   );
 }
 
+/**
+ * Declaration diagnostics as tsgo's emitter collects them: sorted, without repeats of an equal
+ * diagnostic. They are part of the file's signature in build info.
+ */
+function emitterDiagnostics(diagnostics: readonly Diagnostic[]): readonly Diagnostic[] {
+  if (diagnostics.length < 2) return diagnostics;
+  const sorted = diagnostics.toSorted(compareDiagnostics);
+  const result: Diagnostic[] = [];
+  for (const diagnostic of sorted) {
+    // Equal diagnostics compare as 0, so a repeat is among the last ones kept that compare as 0.
+    let repeated = false;
+    for (let i = result.length - 1; i >= 0 && compareDiagnostics(result[i], diagnostic) === 0; i--) {
+      if (equalDiagnostics(result[i], diagnostic)) {
+        repeated = true;
+        break;
+      }
+    }
+    if (!repeated) result.push(diagnostic);
+  }
+  return result;
+}
+
 function getScriptTransformers(host: EmitHost, context: EmitContext, file: SourceFile): Transformer[] {
   const options = host.options;
   const facts = new TypeScriptFacts();
@@ -248,13 +297,13 @@ function isJsxTransformEnabled(options: CompilerOptions): boolean {
 
 function emitJSFile(
   host: EmitHost,
+  context: EmitContext,
   file: SourceFile,
   jsFilePath: string,
   sourceMapFilePath: string,
   result: EmitResult,
 ): boolean {
   const options = host.options;
-  const context = new EmitContext();
   let transformed = file;
   const transformers = getScriptTransformers(host, context, file);
   for (let i = 0; i < transformers.length; i++) {

package/src/compiler/encoder.ts

@@ -1,7 +1,7 @@
-// Encodes a source file in TypeScript 7's binary AST format (protocol version 5), the
+// Encodes a source file in TypeScript 7.1's binary AST format (protocol version 9), the
 // `getSourceFile` payload of the API.
 //
-// Layout: a 44-byte header, string offsets (UTF-8 start/end pairs), string data (the
+// Layout: a 64-byte header, string offsets (UTF-8 start/end pairs), string data (the
 // UTF-8 file text, then strings that aren't slices of it), extended node data,
 // msgpack structured data, and 28-byte node records in visit order. Node positions are
 // UTF-16 offsets.
@@ -197,10 +197,10 @@ import { SyntaxKind } from './syntax-kind.js';
 import { hash128 } from './xxh3.js';
 import { utf8Offsets } from './character-codes.js';
 
-export const protocolVersion = 5;
+export const protocolVersion = 9;
 
 const nodeSize = 28;
-const headerSize = 44;
+const headerSize = 64;
 const nodeListKind = 0xffffffff;
 const noStructuredData = 0xffffffff;
 
@@ -210,6 +210,11 @@ const dataTypeExtended = 2 << 30;
 
 const utf8Encoder = new TextEncoder();
 
+/** A node list record's last word: 1 when the list ends with a comma. */
+function trailingComma(list: NodeList): number {
+  return list.hasTrailingComma() ? 1 : 0;
+}
+
 /** A growable little-endian byte buffer. */
 class ByteWriter {
   bytes: Uint8Array;
@@ -1261,7 +1266,8 @@ function childrenPropertyMask(node: Node): number {
       return node instanceof ModuleDeclaration
         ? (hasModifiers((node as ModuleDeclaration).modifiers) ? 1 : 0) |
             ((node as ModuleDeclaration).name !== undefined ? 2 : 0) |
-            ((node as ModuleDeclaration).body !== undefined ? 4 : 0)
+            ((node as ModuleDeclaration).attributes !== undefined ? 4 : 0) |
+            ((node as ModuleDeclaration).body !== undefined ? 8 : 0)
         : 0;
     case SyntaxKind.ImportEqualsDeclaration:
       return node instanceof ImportEqualsDeclaration
@@ -1381,6 +1387,7 @@ function commonData(node: Node): number {
       if (!(node instanceof ImportClause)) return 0;
       if ((node as ImportClause).phaseModifier === SyntaxKind.TypeKeyword) return 1 << 24;
       if ((node as ImportClause).phaseModifier === SyntaxKind.DeferKeyword) return 2 << 24;
+      if ((node as ImportClause).phaseModifier === SyntaxKind.SourceKeyword) return 3 << 24;
       return 0;
     case SyntaxKind.ImportSpecifier:
       return node instanceof ImportSpecifier ? bit((node as ImportSpecifier).isTypeOnly) << 24 : 0;
@@ -1577,7 +1584,7 @@ class Encoder extends NodeVisitor {
     this.linkSibling(index);
     const positions = this.positions;
     if (positions === undefined)
-      this.nodes.push(nodeListKind, list.pos, list.end, this.parentIndex, list.nodes.length, 0);
+      this.nodes.push(nodeListKind, list.pos, list.end, this.parentIndex, list.nodes.length, trailingComma(list));
     else
       this.nodes.push(
         nodeListKind,
@@ -1585,7 +1592,7 @@ class Encoder extends NodeVisitor {
         positions.of(list.end),
         this.parentIndex,
         list.nodes.length,
-        0,
+        trailingComma(list),
       );
     const saveParent = this.parentIndex;
     this.prevIndex = 0;
@@ -1659,6 +1666,8 @@ class Encoder extends NodeVisitor {
     out.u32(offsetExtended);
     out.u32(offsetStructured);
     out.u32(offsetNodes);
+    // Source file ID and lease ID (u64 each) and binder data offset: 0, none.
+    for (let i = 0; i < 5; i++) out.u32(0);
     out.append(strings.offsets.view());
     out.append(fileText);
     out.append(strings.others.view());
@@ -1787,7 +1796,8 @@ class Encoder extends NodeVisitor {
       );
       out.u32((node as TemplateTail).templateFlags);
     } else if (node instanceof SourceFile) {
-      out.u32(strings.addFileText((node as SourceFile).pos, (node as SourceFile).end));
+      const text = strings.addFileText((node as SourceFile).pos, (node as SourceFile).end);
+      out.u32(text);
       out.u32(strings.add((node as SourceFile).fileName, SyntaxKind.Unknown, 0, 0));
       out.u32(strings.add((node as SourceFile).path, SyntaxKind.Unknown, 0, 0));
       out.u32((node as SourceFile).languageVariant);
@@ -1801,6 +1811,11 @@ class Encoder extends NodeVisitor {
       out.u32(noStructuredData);
       out.u32(noStructuredData);
       out.u32(0);
+      // The original text is the text, and the content mapper fields (span map, supplemental
+      // file names, canonical file name, mapper, virtual file name, diagnostic directives) are
+      // empty: tsc-ts maps no file contents.
+      out.u32(text);
+      for (let i = 0; i < 6; i++) out.u32(noStructuredData);
     } else throw new Error(`no extended data for kind ${node.kind}`);
     return offset;
   }

package/src/compiler/file-include.ts

@@ -597,10 +597,16 @@ export class IncludeProcessor {
     return this.fileIncludeReasons.get(path) ?? [];
   }
 
-  addReason(path: string, reason: FileIncludeReason): void {
+  /** Adds an include reason of the file at `path`; returns the file's reasons. */
+  addReason(path: string, reason: FileIncludeReason): FileIncludeReason[] {
     const reasons = this.fileIncludeReasons.get(path);
-    if (reasons === undefined) this.fileIncludeReasons.set(path, [reason]);
-    else reasons.push(reason);
+    if (reasons === undefined) {
+      const added = [reason];
+      this.fileIncludeReasons.set(path, added);
+      return added;
+    }
+    reasons.push(reason);
+    return reasons;
   }
 
   addProcessingDiagnostic(diagnostic: ProcessingDiagnostic): void {

package/src/compiler/file-loader.ts

@@ -13,7 +13,7 @@ import {
   type Node,
   type SourceFile,
 } from './ast.js';
-import { Diagnostics, type DiagnosticMessage, type MessageWithArgs } from './diagnostics.js';
+import { Diagnostics, type DiagnosticMessage, type MessageWithArgs, messageWithArgs } from './diagnostics.js';
 import { FileIncludeKind, FileIncludeReason, IncludeProcessor, ProcessingDiagnostic } from './file-include.js';
 import type { FileSystem } from './file-system.js';
 import { ModuleResolutionHost, Resolver, getAutomaticTypeDirectiveNames } from './module-resolution.js';
@@ -42,7 +42,7 @@ import {
   takePreparedFile,
 } from './parallel-parse.js';
 import type { PackageJsonLookup } from './package-json.js';
-import { parseSourceFile } from './parser.js';
+import { parseSourceFile, getScriptKindFromFileName } from './parser.js';
 import { mark } from './timeline.js';
 import {
   combinePaths,
@@ -59,6 +59,7 @@ import {
   supportedTSExtensionsWithJsonFlat,
   toFileNameLowerCase,
   toPath,
+  isNetworkPath,
 } from './path.js';
 import {
   getDefaultLibFileName,
@@ -76,6 +77,7 @@ import {
   SourceFileMetadata,
 } from './program-utilities.js';
 import { SyntaxKind } from './syntax-kind.js';
+import { isSourcePhaseImport } from './ast-utilities.js';
 import { hasExtension } from './vfs-match.js';
 import { TokenFlags } from './types.js';
 import {
@@ -140,7 +142,10 @@ export class CompilerHost extends ModuleResolutionHost {
     if (prepared !== undefined) return prepared;
     const text = this.fs.readFile(fileName);
     if (text === undefined) return undefined;
-    return parseSourceFile(fileName, text, new ParseOptions(path, ScriptKind.Unknown, externalModuleIndicatorOptions));
+    // A file without a known extension (with allowNonTsExtensions) parses as TypeScript.
+    const kind = getScriptKindFromFileName(fileName);
+    const scriptKind = kind === ScriptKind.Unknown ? 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. */
@@ -246,6 +251,8 @@ class ParseTask {
   subTasks: ParseTask[] | undefined = 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: SourceFileMetadata = libFileMetadata;
   resolutionsInFile: ModeAwareCache<ResolvedModule> | undefined = undefined;
   resolutionsTrace: MessageWithArgs[] | undefined = undefined;
@@ -256,6 +263,8 @@ class ParseTask {
   jsxRuntimeImport: JsxRuntimeImport | undefined = undefined;
   /** The task of the same file name that was loaded instead of this one. */
   loadedTask: ParseTask | undefined = 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`). */
   readonly byImport: boolean;
 
@@ -303,9 +312,30 @@ class ParseTask {
 
 const noData: readonly ParseTaskData[] = [];
 
+/** The resolution of a module the importing file declares itself: none. */
+const locallyDeclaredModule: ResolvedModule = {
+  resolvedFileName: '',
+  originalPath: '',
+  extension: '',
+  resolvedUsingTsExtension: false,
+  packageId: undefined,
+  isExternalLibraryImport: false,
+  alternateResult: '',
+  resolutionDiagnostics: [],
+};
+
 /** The tasks of one path, by file name casing. */
 class ParseTaskData {
   readonly tasks = new Map<string, ParseTask>();
+  /** Whether a task of the path is queued (`start`). */
+  queued = false;
+  /** The path's first queued task, the first of `tasks`. */
+  first: ParseTask | undefined = 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: PackageId | undefined = undefined;
@@ -315,10 +345,10 @@ class ParseTaskData {
   keptCopy: ParseTaskData | undefined = undefined;
   /** The paths the file's imports and type reference directives add, once collected. */
   added: readonly ParseTaskData[] = noData;
-
-  constructor(task: ParseTask) {
-    this.tasks.set(task.normalizedFilePath, task);
-  }
+  /** The file name `collect` reached the path by first, once it did. */
+  collectedName: string | undefined = undefined;
+  /** The path's include reasons, once `collect` found one: the list in `IncludeProcessor.fileIncludeReasons`. */
+  reasons: FileIncludeReason[] | undefined = undefined;
 }
 
 /** Pending processing of `tasks[index]`. */
@@ -477,7 +507,7 @@ export function needsImportHelpersImportSpecifier(file: SourceFile, options: Com
 
 /** The module `file` imports the JSX runtime from under `options`, or '' if it imports none. */
 export function jsxRuntimeImportOf(file: SourceFile, options: CompilerOptions): string {
-  if (file.scriptKind !== ScriptKind.JSX && file.scriptKind !== ScriptKind.TSX) return '';
+  if (!isSourceFileJS(file) && file.scriptKind !== ScriptKind.TSX) return '';
   return getJSXRuntimeImport(getJSXImplicitImportBase(options, file), options);
 }
 
@@ -557,7 +587,10 @@ export class FileLoader {
   private readonly supportedExtensionsWithJson: readonly (readonly string[])[];
   private readonly maxNodeModuleJsDepth: number;
   private readonly rootTasks: ParseTask[] = [];
-  private readonly taskDataByPath = new Map<string, ParseTaskData>();
+  /** The tasks of each path, created when a task of the path is first queued or built ahead. */
+  private readonly taskData: ParseTaskData[] = [];
+  /** The index in `taskData` of each path's tasks. */
+  private readonly taskDataByPath = new Map<string, number>();
   /** Work queued by `start`, run last-in first-out like tsgo's single-threaded work group. */
   private readonly work: ParseWork[] = [];
   private readonly libFileCache = new Map<string, LibFile>();
@@ -627,7 +660,11 @@ export class FileLoader {
       const loaded = prepared.loaded;
       if (loaded === undefined) continue;
       const subTasks = this.subTasksOf(loaded);
-      for (const task of subTasks) task.path = this.toPath(task.normalizedFilePath);
+      // 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));
     }
   }
@@ -705,7 +742,7 @@ export class FileLoader {
 
   private walk(): void {
     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;
       }
@@ -721,6 +758,7 @@ export class FileLoader {
    */
   release(): void {
     this.rootTasks.length = 0;
+    this.taskData.length = 0;
     this.taskDataByPath.clear();
     this.work.length = 0;
     this.subTasksAhead.clear();
@@ -900,6 +938,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),
     );
@@ -926,6 +965,8 @@ export class FileLoader {
   ): string | ReferenceDiagnostic {
     const allowNonTsExtensions = this.options.allowNonTsExtensions === true;
     const diagnosticFileName = normalizeSlashes(referenceText);
+    if (isNetworkPath(fileName))
+      return new ReferenceDiagnostic(Diagnostics.Network_path_0_is_not_supported, [diagnosticFileName]);
     const fs = this.host.fs;
     if (hasExtension(fileName)) {
       const canonicalFileName = getCanonicalFileName(fileName, fs.useCaseSensitiveFileNames);
@@ -1026,43 +1067,67 @@ export class FileLoader {
   // ---- Loading
 
   private start(tasks: ParseTask[], depth: number): void {
+    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. */
+  private dataIndexOf(path: string): number {
+    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;
+  }
+
   private run(work: ParseWork): void {
     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;
       }
     }
     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;
       data.startedSubTasks = true;
     }
     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) {
@@ -1072,11 +1137,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.
+   */
+  private elides(work: ParseWork): boolean {
+    const task = work.tasks[work.index];
+    return task.elideOnDepth && (task.increaseDepth ? work.depth + 1 : work.depth) > this.maxNodeModuleJsDepth;
   }
 
   /**
@@ -1096,6 +1173,7 @@ export class FileLoader {
       this.loadAutomaticTypeDirectives(task);
       return;
     }
+    if (task.failedLookup) return;
     const redirect = this.mapper.getParseFileRedirect(task.path);
     if (redirect !== '') {
       const redirected = new ParseTask(
@@ -1344,8 +1422,24 @@ export class FileLoader {
     for (let index = 0; index < moduleNames.length; index++) {
       const entry = moduleNames[index];
       const moduleName = getText(entry);
-      if (moduleName === '') continue;
+      // 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(
+                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,
@@ -1412,7 +1506,7 @@ export class FileLoader {
     const redirectFilesByPath = new Map<string, RedirectFile>();
     const packageIdToSourceFile = new Map<string, SourceFile>();
     const checkCasing = this.options.forceConsistentCasingInFileNames !== false;
-    const seen = new Map<ParseTaskData, string>();
+    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.
@@ -1427,13 +1521,13 @@ export class FileLoader {
         // 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);
+          if (includeReason !== undefined) 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 (
@@ -1446,7 +1540,7 @@ export class FileLoader {
           }
           continue;
         }
-        seen.set(data, task.normalizedFilePath);
+        data.collectedName = task.normalizedFilePath;
 
         if (tasksSeenByNameIgnoreCase !== undefined) {
           const lowerCasePath = toFileNameLowerCase(task.path);
@@ -1509,13 +1603,15 @@ 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);
@@ -1599,10 +1695,21 @@ export function releaseLater(loader: FileLoader): void {
   setImmediate(() => loader.release());
 }
 
-function addIncludeReason(processor: IncludeProcessor, task: ParseTask, reason: FileIncludeReason): void {
+function addIncludeReason(
+  processor: IncludeProcessor,
+  taskData: readonly ParseTaskData[],
+  task: ParseTask,
+  reason: FileIncludeReason,
+): void {
   const redirected = task.redirectedParseTask;
-  if (redirected !== undefined) addIncludeReason(processor, redirected, reason);
-  else if (task.loaded) processor.addReason(task.path, reason);
+  if (redirected !== undefined) 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: readonly string[]): ProjectReferenceTask[] {