tsc-ts 0.0.10 → 0.1.1

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[] {

package/src/compiler/help.ts

@@ -8,18 +8,24 @@ import {
   buildOptionDeclarations,
   optionDeclarations,
   optionsForBuild,
-  optionsForWatch,
   sameEnumValue,
   type OptionDeclaration,
 } from './option-declarations.js';
 import type { System } from './tsc-cli.js';
 
-export const version = '7.0.2';
+export const version = '7.1.0-beta';
 
-/** Whether output gets colors: `NO_COLOR` and `FORCE_COLOR` override the TTY check. */
+/**
+ * Whether output gets colors. As in Node, a set `FORCE_COLOR` decides: on when empty, `1`, `2`, `3` or `true`, off
+ * otherwise. Then `NO_COLOR` or `TERM=dumb` turn colors off, else they follow the TTY check.
+ */
 export function defaultIsPretty(sys: System): boolean {
+  if (sys.hasEnvironmentVariable('FORCE_COLOR')) {
+    const forceColor = sys.getEnvironmentVariable('FORCE_COLOR');
+    return forceColor === '' || forceColor === '1' || forceColor === '2' || forceColor === '3' || forceColor === 'true';
+  }
   if (sys.getEnvironmentVariable('NO_COLOR') !== '') return false;
-  if (sys.getEnvironmentVariable('FORCE_COLOR') !== '') return true;
+  if (sys.getEnvironmentVariable('TERM') === 'dumb') return false;
   return sys.writeOutputIsTTY;
 }
 
@@ -262,16 +268,6 @@ function printAllHelp(writer: HelpWriter, options: readonly OptionDeclaration[])
     undefined,
     learnMore(writer),
   );
-  out += sectionOutput(
-    writer,
-    writer.text(Diagnostics.WATCH_OPTIONS),
-    optionsForWatch,
-    false,
-    writer.text(
-      Diagnostics.Including_watch_w_will_start_watching_the_current_project_for_the_file_changes_Once_set_you_can_config_watch_mode_with_Colon,
-    ),
-    undefined,
-  );
   out += sectionOutput(
     writer,
     writer.text(Diagnostics.BUILD_OPTIONS),

package/src/compiler/identifier-name.ts

@@ -0,0 +1,13 @@
+import type { ProgramLifetime } from '@scriptc/types';
+
+/**
+ * The text of an identifier. The identifiers a parser's scanner interns with the same text share one
+ * (scanner.ts `IdentifierTable`), and natively an identifier refers to it in 4 bytes.
+ */
+export class IdentifierName implements ProgramLifetime {
+  readonly text: string;
+
+  constructor(text: string) {
+    this.text = text;
+  }
+}

package/src/compiler/incremental.ts

@@ -41,6 +41,7 @@ import {
   modeMismatchDetails,
   moduleNotFoundDetails,
   resolveExternalModuleName,
+  getImportAttributesTypeForModuleSpecifier,
 } from './checker-modules.js';
 import { getSymbolAtLocation } from './checker-services.js';
 import { resolveAlias } from './checker-symbols.js';
@@ -1231,7 +1232,17 @@ function addOwnReferencedFiles(checked: CheckedProgram, file: SourceFile, refere
   // call that does not initialize a variable (`exports.a = require("./a").a`), so its build info leaves out that
   // module and its incremental builds keep outputs that depend on it.
   for (const importName of file.imports) {
-    addReferencedFilesFromSymbol(file, referenced, resolveExternalModuleName(checker, importName, importName, true));
+    addReferencedFilesFromSymbol(
+      file,
+      referenced,
+      resolveExternalModuleName(
+        checker,
+        importName,
+        importName,
+        true,
+        getImportAttributesTypeForModuleSpecifier(checker, importName),
+      ),
+    );
   }
   const sourceFileDirectory = getDirectoryPath(file.fileName);
   for (const reference of file.referencedFiles) {
@@ -1275,9 +1286,16 @@ function programToSnapshot(checked: CheckedProgram, oldSnapshot: Snapshot | unde
   // Reuse from the old state.
   if (oldSnapshot !== undefined) {
     if (options.composite === true) snapshot.latestChangedDtsFile = oldSnapshot.latestChangedDtsFile;
-    for (const path of oldSnapshot.changedFilesSet) snapshot.changedFilesSet.add(path);
-    for (const [path, kind] of oldSnapshot.affectedFilesPendingEmit) snapshot.affectedFilesPendingEmit.set(path, kind);
     snapshot.buildInfoEmitPending = oldSnapshot.buildInfoEmitPending;
+    // Changes and pending emit of files no longer in the program are dropped, which changes the build info.
+    for (const path of oldSnapshot.changedFilesSet) {
+      if (program.getSourceFileByPath(path) !== undefined) snapshot.changedFilesSet.add(path);
+      else snapshot.buildInfoEmitPending = true;
+    }
+    for (const [path, kind] of oldSnapshot.affectedFilesPendingEmit) {
+      if (program.getSourceFileByPath(path) !== undefined) snapshot.affectedFilesPendingEmit.set(path, kind);
+      else snapshot.buildInfoEmitPending = true;
+    }
     snapshot.hasErrorsFromOldState = oldSnapshot.hasErrors;
     snapshot.hasSemanticErrorsFromOldState = oldSnapshot.hasSemanticErrors;
     const oldPackageJsons = oldSnapshot.packageJsons;
@@ -1425,13 +1443,23 @@ function programToSnapshot(checked: CheckedProgram, oldSnapshot: Snapshot | unde
   if (oldSnapshot !== undefined) {
     for (const [path, oldInfo] of oldSnapshot.fileInfos) {
       if (snapshot.fileInfos.has(path)) continue;
-      if (oldInfo.affectsGlobalScope) {
-        for (const file of snapshot.getAllFilesExcludingDefaultLibraryFile(program, undefined)) {
-          snapshot.addFileToChangeSet(file.path);
-        }
-        globalFileRemoved = true;
-      } else snapshot.buildInfoEmitPending = true;
-      break;
+      snapshot.buildInfoEmitPending = true;
+      snapshot.changedFilesSet.delete(path);
+      snapshot.affectedFilesPendingEmit.delete(path);
+      if (oldInfo.affectsGlobalScope) globalFileRemoved = true;
+    }
+    if (globalFileRemoved) invalidateGlobalScope(checked, snapshot);
+  }
+
+  // A file that no longer affects the global scope changes it as its removal would.
+  if (oldSnapshot !== undefined && !globalFileRemoved) {
+    for (const [path, oldInfo] of oldSnapshot.fileInfos) {
+      if (!oldInfo.affectsGlobalScope) continue;
+      const info = snapshot.fileInfos.get(path);
+      if (info !== undefined && !info.affectsGlobalScope) {
+        invalidateGlobalScope(checked, snapshot);
+        break;
+      }
     }
   }
 
@@ -1460,6 +1488,19 @@ function programToSnapshot(checked: CheckedProgram, oldSnapshot: Snapshot | unde
   return snapshot;
 }
 
+/**
+ * After a change to the global scope, every file but the default libraries is changed, and the default
+ * libraries that are checked are checked again.
+ */
+function invalidateGlobalScope(checked: CheckedProgram, snapshot: Snapshot): void {
+  const program = checked.program;
+  snapshot.buildInfoEmitPending = true;
+  for (const file of program.getSourceFiles()) {
+    if (!program.isSourceFileDefaultLibrary(file.path)) snapshot.addFileToChangeSet(file.path);
+    else if (!checked.skipTypeChecking(file, true)) snapshot.semanticDiagnosticsPerFile.delete(file.path);
+  }
+}
+
 // ---- Affected files
 
 class AffectedFilesHandler {
@@ -1510,7 +1551,12 @@ class AffectedFilesHandler {
   private computeDtsSignature(file: SourceFile): string {
     const known = this.incremental.signatures.get(file.path);
     if (known !== undefined) return known;
-    return declarationSignature(this.incremental.emitter, file, this.snapshot.options);
+    const done = this.incremental.beginNestedEmit();
+    try {
+      return declarationSignature(this.incremental.emitter, file, this.snapshot.options);
+    } finally {
+      done();
+    }
   }
 
   updateShapeSignature(file: SourceFile, useFileVersionAsSignature: boolean): boolean {
@@ -1519,7 +1565,10 @@ class AffectedFilesHandler {
     if (info === undefined) return false;
     const previous = info.signature;
     let signature = '';
-    if (!file.isDeclarationFile && !useFileVersionAsSignature) signature = this.computeDtsSignature(file);
+    // A JSON file has no declaration output, so its version is its signature, which invalidates its importers.
+    if (!file.isDeclarationFile && !isJsonSourceFile(file) && !useFileVersionAsSignature) {
+      signature = this.computeDtsSignature(file);
+    }
     if (signature === '') signature = info.version;
     this.updatedSignatures.set(file.path, signature);
     return signature !== previous;
@@ -1549,7 +1598,7 @@ class AffectedFilesHandler {
     const info = this.snapshot.fileInfos.get(file.path);
     if (info !== undefined && info.affectsGlobalScope) {
       this.hasAllFilesExcludingDefaultLibraryFile = true;
-      this.snapshot.getAllFilesExcludingDefaultLibraryFile(this.program, file);
+      return this.snapshot.getAllFilesExcludingDefaultLibraryFile(this.program, file);
     }
     if (this.snapshot.options.isolatedModules === true) return [file];
     const seen = this.forEachFileReferencedBy(file, (currentFile) => {
@@ -1966,7 +2015,7 @@ class EmitFilesHandler {
       results.push(
         declarations !== undefined
           ? this.writeThreadOutputs(file, declarations, writer)
-          : program.emitter.emit([file], EmitOnly.Dts, wrapped),
+          : program.emitter.emit([file], emitOnly === EmitOnly.Dts ? EmitOnly.Dts : EmitOnly.DtsAfterJs, wrapped),
       );
     return combineEmitResults(results);
   }
@@ -2558,6 +2607,7 @@ export class IncrementalProgram extends CompilerProgram {
     readonly signatures: ReadonlyMap<string, string> = new Map(),
   ) {
     super(checked, times);
+    checked.globalsInFileDiagnostics = true;
     this.snapshot = programToSnapshot(checked, oldSnapshot);
   }
 
@@ -2565,6 +2615,25 @@ export class IncrementalProgram extends CompilerProgram {
     return this.snapshot.hasChangedDtsFile;
   }
 
+  /** Time spent in declaration emit for signatures while checking (`computeDtsSignature`), not yet taken. */
+  private nestedEmitTime = 0;
+  private nestedEmitDepth = 0;
+  private nestedEmitStart = 0;
+
+  /** Starts timing a nested declaration emit; returns the function that ends it. */
+  beginNestedEmit(): () => void {
+    if (this.nestedEmitDepth++ === 0) this.nestedEmitStart = performance.now();
+    return () => {
+      if (--this.nestedEmitDepth === 0) this.nestedEmitTime += performance.now() - this.nestedEmitStart;
+    };
+  }
+
+  override takeNestedEmitTime(): number {
+    const time = this.nestedEmitTime;
+    this.nestedEmitTime = 0;
+    return time;
+  }
+
   /**
    * The global diagnostics found before `filesToCheck` computed the affected files, which the program
    * reports before its semantic diagnostics (`getGlobalDiagnostics(false)`), as when they are computed
@@ -2697,10 +2766,9 @@ export class IncrementalProgram extends CompilerProgram {
   emit(writer: OutputWriter): EmitResult {
     const options = this.snapshot.options;
     let result: EmitResult | undefined;
-    if (options.noEmit === true) {
-      result = new EmitResult();
-      result.emitSkipped = true;
-    } else result = handleNoEmitOnError(this);
+    // A `noEmit` program emits only its build info, and its emit is not skipped (tsgo's `HandleNoEmitOptions`).
+    if (options.noEmit === true) result = new EmitResult();
+    else result = handleNoEmitOnError(this);
     if (result !== undefined) {
       const buildInfoResult = this.emitBuildInfo(writer);
       if (buildInfoResult !== undefined) {

package/src/compiler/init.ts

@@ -2,12 +2,7 @@
  * The tsconfig.json written by `tsc --init`.
  */
 import { Diagnostics, localizeMessage, type DiagnosticMessage, type Locale } from './diagnostics.js';
-import {
-  compilerOptionsByName,
-  sameEnumValue,
-  watchOptionsByName,
-  type OptionDeclaration,
-} from './option-declarations.js';
+import { compilerOptionsByName, sameEnumValue, type OptionDeclaration } from './option-declarations.js';
 import { JsxEmit, ModuleDetectionKind, ModuleKind, ScriptTarget, type OptionValue } from './options.js';
 
 const enum Commented {
@@ -124,7 +119,7 @@ class ConfigWriter {
 }
 
 function formatValue(name: string, value: OptionValue): string {
-  const option = compilerOptionsByName.get(name) ?? watchOptionsByName.get(name);
+  const option = compilerOptionsByName.get(name);
   if (value === null) return 'null';
   if (typeof value === 'boolean') return value ? 'true' : 'false';
   if (typeof value === 'number' || typeof value === 'string') return formatScalar(value, option);