tsc-ts 0.0.7 → 0.0.9

package/src/compiler/program-checker.ts

@@ -26,6 +26,7 @@ import {
   type SourceFileMetadata,
 } from './program-utilities.js';
 import { bindSourceFile } from './binder.js';
+import { checkSourceFileRange } from './checker-source-file.js';
 import { computeLineOfPosition } from './scanner.js';
 import { CommentDirectiveKind } from './types.js';
 
@@ -313,6 +314,38 @@ export class CheckedProgram {
     return result;
   }
 
+  /**
+   * Checks the statements `start` to `end` of the declaration file `file` with this checker, one of the
+   * ranges that several checkers check it in (`checkSourceFileRange`, parallel-check.ts), and returns
+   * whether the checker then has diagnostics in the file.
+   */
+  checkRange(file: SourceFile, start: number, end: number): boolean {
+    return checkSourceFileRange(this.checker, file, start, end);
+  }
+
+  /**
+   * The diagnostics of `file`, as `unfilteredDiagnosticsOfFile` gives them, where checkers checked it in
+   * ranges and found no diagnostics in it (`checkRange`).
+   */
+  unfilteredDiagnosticsOfCleanRanges(file: SourceFile): Diagnostic[] {
+    const result = this.getBindAndCheckDiagnostics(file, []);
+    for (const d of this.getIncludeProcessorDiagnostics(file)) result.push(d);
+    return result;
+  }
+
+  /**
+   * The diagnostics of `file`, as `unfilteredDiagnosticsOfFile` gives them, from a new checker that checks it
+   * whole: for a file checked in ranges that found diagnostics in it (parallel-check.ts), part of which this
+   * thread's checker may have checked.
+   */
+  unfilteredDiagnosticsOfFileOnNewChecker(file: SourceFile): Diagnostic[] {
+    const checker = this.createChecker();
+    const result = this.getBindAndCheckDiagnostics(file, checker.getDiagnostics(file));
+    disposeChecker(checker);
+    for (const d of this.getIncludeProcessorDiagnostics(file)) result.push(d);
+    return result;
+  }
+
   /**
    * The bind and check diagnostics of `file` before `noEmit` filtering and without include errors.
    * Once checker threads checked the program, they come from the threads' diagnostics of the file,
@@ -395,10 +428,11 @@ export class CheckedProgram {
     return sortAndDeduplicateDiagnostics(result);
   }
 
-  private getBindAndCheckDiagnostics(file: SourceFile): Diagnostic[] {
+  /** `checks` are the checker's diagnostics of `file`. */
+  private getBindAndCheckDiagnostics(file: SourceFile, checks?: readonly Diagnostic[]): Diagnostic[] {
     const options = this.program.options;
     const diagnostics = file.bindDiagnostics.slice();
-    for (const d of this.checker.getDiagnostics(file)) diagnostics.push(d);
+    for (const d of checks ?? this.checker.getDiagnostics(file)) diagnostics.push(d);
     if (isPlainJSFile(file, options)) {
       const result: Diagnostic[] = [];
       for (const d of diagnostics) if (plainJSErrors.has(d.code)) result.push(d);

package/src/compiler/thread-entry.ts

@@ -54,6 +54,7 @@ export interface CheckerThreadData {
   readonly emits: boolean;
   readonly emitKinds: number[] | undefined;
   readonly checking: boolean;
+  readonly units: number[];
 }
 
 export interface ParseThreadData {
@@ -75,7 +76,19 @@ export interface ReferenceThreadData {
  */
 export function startThreads(spawn: ThreadSpawn, drivers: ThreadDrivers, args: readonly string[]): void {
   parallelCheck.writer = drivers.outputWriter();
-  parallelCheck.spawn = (program, index, counter, order, nodeIds, symbolIds, reserved, emits, emitKinds, checking) =>
+  parallelCheck.spawn = (
+    program,
+    index,
+    counter,
+    order,
+    nodeIds,
+    symbolIds,
+    reserved,
+    emits,
+    emitKinds,
+    checking,
+    units,
+  ) =>
     spawn({
       kind: 'check',
       program,
@@ -89,6 +102,7 @@ export function startThreads(spawn: ThreadSpawn, drivers: ThreadDrivers, args: r
       emits,
       emitKinds,
       checking,
+      units,
     });
   if (sharesPublishedGraphs) {
     parallelParse.spawn = (configFileName, counter, index) =>
@@ -161,6 +175,7 @@ function runCheckerThread(job: CheckerThreadData, drivers: ThreadDrivers): void
           job.emits,
           job.emitKinds,
           job.checking,
+          job.units,
         );
   // Packed results are copied: nothing this thread allocated stays reachable after it ends.
   if (packsResults) parentPort!.postMessage(packResult(result, program!));

package/src/library/diagnostics.ts

@@ -70,3 +70,26 @@ export function programDiagnostics(
       return [];
   }
 }
+
+/**
+ * What `semantic` answers for each of `files` and what `global` answers, after checking `files` and
+ * no other file. Checking one file can add diagnostics located in another, so every file is checked
+ * before any file's diagnostics are collected. With every file of the program listed, the answers are
+ * those of the full check.
+ */
+export function checkedFileDiagnostics(
+  checked: CheckedProgram,
+  files: readonly SourceFile[],
+): { files: (readonly CompilerDiagnostic[])[]; global: readonly CompilerDiagnostic[] } {
+  for (const file of files) checked.getSemanticDiagnostics(file);
+  const program = checked.program;
+  const global = [
+    ...program.getConfigFileParsingDiagnostics(),
+    ...program.getProgramDiagnostics(),
+    ...checked.getGlobalDiagnostics(),
+  ];
+  return {
+    files: files.map((file) => checked.getSemanticDiagnostics(file)),
+    global: sortAndDeduplicateDiagnostics(global).filter((d) => d.file === undefined),
+  };
+}