tsc-ts 0.0.5 → 0.0.6

package/src/compiler/file-include.ts

@@ -30,13 +30,12 @@ export const enum FileIncludeKind {
   AutomaticTypeDirectiveFile,
 }
 
-/** 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 {
-  private relativeDiagnostic: Diagnostic | undefined = undefined;
-  private absoluteDiagnostic: Diagnostic | undefined = undefined;
-  private location: ReferenceFileLocation | undefined = undefined;
-  private relatedInfo: Diagnostic | null | undefined = undefined;
-
   private constructor(
     readonly kind: FileIncludeKind,
     /** The referencing file's path, for references from a file. */
@@ -80,7 +79,7 @@ export class FileIncludeReason {
     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(): FileIncludeReason {
     return new FileIncludeReason(this.kind, this.file, this.index, this.synthetic, this.typeReference, this.packageId);
   }
@@ -90,7 +89,8 @@ export class FileIncludeReason {
   }
 
   getReferencedLocation(program: Program): ReferenceFileLocation {
-    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');
     let location: ReferenceFileLocation;
@@ -142,18 +142,20 @@ export class FileIncludeReason {
           false,
         );
     }
-    if (!program.isShared()) this.location = location;
+    if (!program.isShared()) 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: Program, relative: boolean): Diagnostic {
-    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;
-    if (relative) this.relativeDiagnostic = diagnostic;
-    else this.absoluteDiagnostic = diagnostic;
+    const own = program.includeProcessor.newCacheOf(this);
+    if (relative) own.relativeDiagnostic = diagnostic;
+    else own.absoluteDiagnostic = diagnostic;
     return diagnostic;
   }
 
@@ -286,9 +288,10 @@ export class FileIncludeReason {
 
   /** Where in the config or a file this reason is written, as related information; `undefined` if nowhere. */
   toRelatedInfo(program: Program): Diagnostic | undefined {
-    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;
+    if (!program.isShared()) program.includeProcessor.newCacheOf(this).relatedInfo = info ?? null;
     return info;
   }
 
@@ -425,6 +428,14 @@ export class ProcessingDiagnostic {
     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: (reason: FileIncludeReason) => FileIncludeReason): ProcessingDiagnostic {
+    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: Program): Diagnostic {
     const reason = this.reason;
     if (this.kind === ProcessingDiagnosticKind.UnknownReference && reason !== undefined) {
@@ -509,20 +520,77 @@ function stripLibAffixes(name: string): string {
 }
 
 /** 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: Diagnostic | undefined = undefined;
+  absoluteDiagnostic: Diagnostic | undefined = undefined;
+  location: ReferenceFileLocation | undefined = undefined;
+  relatedInfo: Diagnostic | null | undefined = undefined;
+}
+
 export class IncludeProcessor {
   private computed: Diagnostic[] | undefined = undefined;
+  /** What each reason computed for this processor's program, once it computed something. */
+  private readonly reasonCaches = new Map<FileIncludeReason, ReasonCache>();
   private compilerOptionsObject: ObjectLiteralExpression | undefined = undefined;
   private compilerOptionsComputed = false;
   private readonly redirectAndFileFormat = new Map<string, readonly Diagnostic[]>();
+  /** The number of processing diagnostics when the program was created (`noteProgramCreated`). */
+  private createdCount: number | undefined = undefined;
 
   constructor(
     readonly fileIncludeReasons = new Map<string, FileIncludeReason[]>(),
     readonly processingDiagnostics: ProcessingDiagnostic[] = [],
   ) {}
 
-  /** A processor with these reasons and processing diagnostics, whose diagnostics are computed for another program. */
-  copy(): IncludeProcessor {
-    return new IncludeProcessor(this.fileIncludeReasons, this.processingDiagnostics);
+  /** What `reason` computed for this processor's program, if anything. */
+  cacheOf(reason: FileIncludeReason): ReasonCache | undefined {
+    return this.reasonCaches.get(reason);
+  }
+
+  /** The cache of `reason`, created if needed. */
+  newCacheOf(reason: FileIncludeReason): ReasonCache {
+    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?: string): IncludeProcessor {
+    const created = this.processingDiagnostics.slice(0, this.createdCount ?? this.processingDiagnostics.length);
+    if (replaced === undefined) return new IncludeProcessor(this.fileIncludeReasons, created);
+    const copies = new Map<FileIncludeReason, FileIncludeReason>();
+    const renew = (reason: FileIncludeReason): FileIncludeReason => {
+      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<string, FileIncludeReason[]>();
+    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(): void {
+    this.createdCount = this.processingDiagnostics.length;
   }
 
   reasonsOf(path: string): readonly FileIncludeReason[] {

package/src/compiler/file-loader.ts

@@ -36,6 +36,7 @@ import {
   LoadKind,
   type LoadJobs,
   type PreparedFile,
+  isPrepared,
   preparedLoad,
   preparedPackageJsonLookups,
   takePreparedFile,
@@ -205,7 +206,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 {
   constructor(
@@ -416,7 +417,7 @@ export function withReplacedFile(processed: ProcessedFiles, file: SourceFile): P
     processed.importHelpersImportSpecifiers,
     processed.libFiles,
     processed.sourceFilesFoundSearchingNodeModules,
-    processed.includeProcessor.copy(),
+    processed.includeProcessor.copy(file.path),
     processed.outputFileToProjectReferenceSource,
     processed.redirectTargets,
     processed.redirectFilesByPath,
@@ -527,6 +528,10 @@ export class FileLoader {
   private rootFilesAdded = 0;
   /** The sub-tasks of prepared files, by file name, built ahead by `takeAhead`. */
   private readonly subTasksAhead = new Map<string, SubTasksAhead>();
+  /** Whether the work of the root tasks is queued (`startRootTasks`). */
+  private rootTasksStarted = false;
+  /** Set while `walkAhead` runs: the walk stops at work that would parse a file not prepared yet. */
+  private 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
@@ -573,11 +578,8 @@ export class FileLoader {
     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).
-   */
-  takeAhead(files: readonly PreparedFile[]): void {
+  /** Builds ahead what loading takes from each of `files` (`takeLoadedFile`). */
+  private takeAhead(files: readonly PreparedFile[]): void {
     for (const prepared of files) {
       const loaded = prepared.loaded;
       if (loaded === undefined) continue;
@@ -587,10 +589,39 @@ export class FileLoader {
     }
   }
 
+  /**
+   * 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: readonly PreparedFile[]): void {
+    this.takeAhead(files);
+    if (!this.rootTasksStarted && this.rootFilesAdded < this.config.fileNames.length) return;
+    this.startRootTasks();
+    this.walkingAhead = true;
+    this.walk();
+    this.walkingAhead = false;
+  }
+
   load(): ProcessedFiles {
-    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. */
+  private addLastRootTasks(): void {
+    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));
@@ -604,32 +635,54 @@ 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,
-        ),
-      );
-    }
+    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');
+  /** Adds the last root tasks and queues the work of every root task, once every root file's task is added. */
+  private startRootTasks(): void {
+    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()) this.run(work);
-    mark('loader walked');
-    const result = this.collect();
-    mark('loader collected');
-    this.mapper.loader = undefined;
-    return result;
+  }
+
+  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)) {
+        this.work.push(work);
+        return;
+      }
+      this.run(work);
+    }
+  }
+
+  /**
+   * 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 {
+    this.rootTasks.length = 0;
+    this.taskDataByPath.clear();
+    this.work.length = 0;
+    this.subTasksAhead.clear();
+    this.referenceTasks.clear();
+    this.paths.clear();
   }
 
   /**
@@ -983,6 +1036,17 @@ 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.
+   */
+  private parsesUnprepared(task: ParseTask, data: ParseTaskData): boolean {
+    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;
+  }
+
   private loadTask(task: ParseTask): void {
     task.loaded = true;
     if (task.isForAutomaticTypeDirective) {
@@ -1092,7 +1156,7 @@ export class FileLoader {
         new ParseTask(
           reference.normalizedFilePath,
           libFile,
-          reference.reason.copy(),
+          reference.reason,
           false,
           reference.increaseDepth,
           reference.elideOnDepth,
@@ -1453,6 +1517,11 @@ export class FileLoader {
 
 const noPackageJsonLookups: readonly PackageJsonLookup[] = [];
 
+/** Releases `loader` (`FileLoader.release`) on a later turn of the event loop, while checking runs. */
+export function releaseLater(loader: FileLoader): void {
+  setImmediate(() => loader.release());
+}
+
 function addIncludeReason(processor: IncludeProcessor, task: ParseTask, reason: FileIncludeReason): void {
   const redirected = task.redirectedParseTask;
   if (redirected !== undefined) addIncludeReason(processor, redirected, reason);

package/src/compiler/incremental.ts

@@ -89,10 +89,10 @@ import {
   isDeclarationFileName,
   toPath,
 } from './path.js';
-import { lastSymbolIdValue, SymbolFlags, type Symbol } from './symbol.js';
 import type { ParsedCommandLine } from './tsconfig.js';
 import { hash128String, toHex } from './xxh3.js';
 import { preparedVersion } from './parallel-parse.js';
+import { getDeclarations, lastSymbolIdValue, type Symbol, SymbolFlags } from './symbol.js';
 
 /** The hash of file text that build info records as a version or signature. */
 export function computeHash(text: string): string {
@@ -1191,7 +1191,7 @@ function isModuleWithStringLiteralName(node: Node): boolean {
 
 function addReferencedFilesFromSymbol(file: SourceFile, referenced: Set<string>, symbol: Symbol | undefined): void {
   if (symbol === undefined) return;
-  for (const declaration of symbol.declarations) {
+  for (const declaration of getDeclarations(symbol)) {
     const declarationFile = getSourceFileOfNode(declaration);
     if (declarationFile !== file) referenced.add(declarationFile.path);
   }
@@ -1259,7 +1259,7 @@ function getAmbientModuleFiles(checked: CheckedProgram): string[] {
   const result = new Set<string>();
   for (const [name, symbol] of checked.checker.globals) {
     if (name.length >= 2 && name.charCodeAt(0) === 0x22 && name.charCodeAt(name.length - 1) === 0x22) {
-      for (const declaration of symbol.declarations) result.add(getSourceFileOfNode(declaration).path);
+      for (const declaration of getDeclarations(symbol)) result.add(getSourceFileOfNode(declaration).path);
     }
   }
   return [...result];
@@ -1620,7 +1620,7 @@ class AffectedFilesHandler {
         const aliased = resolveAlias(checker, exported);
         if (aliased === exported) continue;
         if ((aliased.flags & SymbolFlags.ConstEnum) !== 0) {
-          if (aliased.declarations.some((d) => getSourceFileOfNode(d) === affectedFile)) {
+          if (getDeclarations(aliased).some((d) => getSourceFileOfNode(d) === affectedFile)) {
             invalidateJsFiles = true;
             break;
           }
@@ -2529,7 +2529,41 @@ export class IncrementalProgram extends CompilerProgram {
   }
 
   /**
-   * For checker threads that check `files` (from `filesToCheck`) and emit them, what the emit of each
+   * The files checker threads take in a rebuild: those `filesToCheck` returns, then the files whose
+   * semantic diagnostics the build info holds but whose outputs are pending (after a change of the
+   * options that select outputs, or where an earlier build did not write them). Emitting a file asks
+   * the checker about it, so threads that check and emit it spare this thread that work; the
+   * diagnostics reported for it are still those of the build info. Where no file needs checking
+   * (`checksOnCheckers` false), the threads only emit, and emit checks what it needs.
+   */
+  filesForCheckers(): SourceFile[] {
+    const result = this.filesToCheck();
+    this.checksOnCheckers = result.length > 0;
+    const snapshot = this.snapshot;
+    if (snapshot.options.noEmit === true || snapshot.affectedFilesPendingEmit.size === 0) return result;
+    const program = this.program;
+    const taken = new Set(result);
+    for (const [path, emitKind] of snapshot.affectedFilesPendingEmit) {
+      if (getPendingEmitKind(emitKind, 0) === 0) continue;
+      const file = program.getSourceFileByPath(path);
+      if (
+        file === undefined ||
+        taken.has(file) ||
+        this.checked.skipTypeChecking(file) ||
+        !program.sourceFileMayBeEmitted(file, false)
+      )
+        continue;
+      taken.add(file);
+      result.push(file);
+    }
+    return result;
+  }
+
+  /** Whether the files `filesForCheckers` returned last include files to check, not only files to emit. */
+  checksOnCheckers = true;
+
+  /**
+   * For checker threads that check `files` (from `filesForCheckers`) and emit them, what the emit of each
    * file includes, by file index: its pending emit (`EmitFilesHandler.emitFilesIncremental`), or -1.
    * The incremental program's emit then takes what the threads emitted.
    */