tsc-ts 0.0.5 → 0.0.7

package/src/compiler/diagnostics.ts

@@ -2,7 +2,7 @@
  * Diagnostics: message lookup and localization, the `Diagnostic` type, and tsc's plain and
  * pretty diagnostic output.
  */
-import { CharacterCodes, isDigit, isUnicodeWhiteSpace, utf8Length } from './character-codes.js';
+import { isDigit, isUnicodeWhiteSpace, utf8Length } from './character-codes.js';
 import { Locale, translations } from './diagnostic-locales.js';
 import { Diagnostics, messageCodes, messageFlags, messageKeys, messageTexts } from './diagnostic-messages.js';
 import { getPathComponentsRelativeTo, getPathFromPathComponents, isRootedDiskPath, pathIsAbsolute } from './path.js';
@@ -146,15 +146,15 @@ function toWellFormed(text: string): string {
 /**
  * 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: Map<DiagnosticFile, DiagnosticFile> | undefined = 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(): void {
   if (threadCopies === undefined) threadCopies = new Map<DiagnosticFile, DiagnosticFile>();
@@ -174,21 +174,15 @@ function threadCopyOf(file: DiagnosticFile): DiagnosticFile | undefined {
   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: Uint16Array, pos: number, end: number): number {
-  for (let i = pos | 0; i < end; i = (i + 1) | 0) {
-    const c = units[i] | 0;
-    if (c <= CharacterCodes.carriageReturn || c >= 0x80) return i;
-  }
-  return end;
-}
+/** The empty value of a file's position tables until they are computed. */
+const noNumbers: readonly number[] = [];
 
 /** The text of a file diagnostics point into. */
 export class DiagnosticFile {
   readonly fileName: string;
   readonly text: string;
   // Computed on first use; never empty once computed.
-  private lineStarts: number[] = [];
+  private lineStarts: readonly number[] = noNumbers;
   /** Whether this is a thread's copy of a possibly shared file (`threadCopyOf`). */
   isThreadCopy = false;
 
@@ -206,36 +200,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: Uint16Array): void {
-    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: number[] = [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 === CharacterCodes.lineFeed ||
-        (ch === CharacterCodes.carriageReturn &&
-          (i + 1 >= length || (units[(i + 1) | 0] | 0) !== CharacterCodes.lineFeed)) ||
-        ch === CharacterCodes.lineSeparator ||
-        ch === CharacterCodes.paragraphSeparator
-      )
-        lineStarts.push(i + 1);
-    }
-    this.lineStarts = lineStarts;
-  }
-
   /** Start offsets of each line, split at CR, LF, CRLF, LS and PS. */
   getLineStarts(): readonly number[] {
     if (this.lineStarts.length === 0) {
@@ -249,8 +213,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.
   private nonASCIIStarts: number[] | undefined = undefined;
-  private nonASCIILengths: number[] = [];
-  private extraBytes: number[] = [];
+  private nonASCIILengths: readonly number[] = noNumbers;
+  private extraBytes: readonly number[] = noNumbers;
 
   private getNonASCIIStarts(): number[] {
     let starts = this.nonASCIIStarts;
@@ -260,8 +224,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: number[] = [];
+        const extraBytes: number[] = [];
         let extra = 0;
         for (let i = 0; i < bytes.length; i++) {
           const b = bytes[i]!;
@@ -274,6 +238,8 @@ export class DiagnosticFile {
           extraBytes.push(extra);
           i += length - 1;
         }
+        this.nonASCIILengths = lengths;
+        this.extraBytes = extraBytes;
       }
       this.nonASCIIStarts = starts;
     }

package/src/compiler/encoder.ts

@@ -186,6 +186,11 @@ import {
   YieldExpression,
   BigIntLiteral,
   Identifier,
+  propertyAssignmentPostfixToken,
+  propertyAssignmentType,
+  callQuestionDotToken,
+  propertyAssignmentModifiers,
+  callTypeArguments,
 } from './ast.js';
 import { getJSDoc } from './parser.js';
 import { SyntaxKind } from './syntax-kind.js';
@@ -883,8 +888,8 @@ function childrenPropertyMask(node: Node): number {
     case SyntaxKind.CallExpression:
       return node instanceof CallExpression
         ? ((node as CallExpression).expression !== undefined ? 1 : 0) |
-            ((node as CallExpression).questionDotToken !== undefined ? 2 : 0) |
-            ((node as CallExpression).typeArguments !== undefined ? 4 : 0) |
+            (callQuestionDotToken(node as CallExpression) !== undefined ? 2 : 0) |
+            (callTypeArguments(node as CallExpression) !== undefined ? 4 : 0) |
             ((node as CallExpression).arguments !== undefined ? 8 : 0)
         : 0;
     case SyntaxKind.NewExpression:
@@ -938,10 +943,10 @@ function childrenPropertyMask(node: Node): number {
       return node instanceof SpreadAssignment ? ((node as SpreadAssignment).expression !== undefined ? 1 : 0) : 0;
     case SyntaxKind.PropertyAssignment:
       return node instanceof PropertyAssignment
-        ? (hasModifiers((node as PropertyAssignment).modifiers) ? 1 : 0) |
+        ? (hasModifiers(propertyAssignmentModifiers(node as PropertyAssignment)) ? 1 : 0) |
             ((node as PropertyAssignment).name !== undefined ? 2 : 0) |
-            ((node as PropertyAssignment).postfixToken !== undefined ? 4 : 0) |
-            ((node as PropertyAssignment).type !== undefined ? 8 : 0) |
+            (propertyAssignmentPostfixToken(node as PropertyAssignment) !== undefined ? 4 : 0) |
+            (propertyAssignmentType(node as PropertyAssignment) !== undefined ? 8 : 0) |
             ((node as PropertyAssignment).initializer !== undefined ? 16 : 0)
         : 0;
     case SyntaxKind.ShorthandPropertyAssignment:

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.
    */