tsc-ts 0.0.5 → 0.0.7

package/src/compiler/transformers/visitor-base.ts

@@ -170,6 +170,11 @@ import {
   WithStatement,
   YieldExpression,
   type Node,
+  propertyAssignmentPostfixToken,
+  propertyAssignmentType,
+  callQuestionDotToken,
+  propertyAssignmentModifiers,
+  callTypeArguments,
 } from '../ast.js';
 import { SyntaxKind } from '../syntax-kind.js';
 import { VisitorHooks } from './visitor-hooks.js';
@@ -381,8 +386,8 @@ export abstract class VisitorBase extends VisitorHooks {
           return this.factory.updateCallExpression(
             node,
             required(this.visitNode(node.expression), node.expression),
-            asOptionalToken(this.visitNode(node.questionDotToken)),
-            this.visitNodes(node.typeArguments),
+            asOptionalToken(this.visitNode(callQuestionDotToken(node))),
+            this.visitNodes(callTypeArguments(node)),
             this.visitNodes(node.arguments)!,
             node.flags,
           );
@@ -1301,10 +1306,10 @@ export abstract class VisitorBase extends VisitorHooks {
         if (node instanceof PropertyAssignment)
           return this.factory.updatePropertyAssignment(
             node,
-            this.visitModifiers(node.modifiers),
+            this.visitModifiers(propertyAssignmentModifiers(node)),
             required(this.visitNode(node.name), node.name),
-            asOptionalToken(this.visitNode(node.postfixToken)),
-            this.visitNode(node.type),
+            asOptionalToken(this.visitNode(propertyAssignmentPostfixToken(node))),
+            this.visitNode(propertyAssignmentType(node)),
             required(this.visitNode(node.initializer), node.initializer),
           );
         break;

package/src/compiler/tsc-build.ts

@@ -721,16 +721,13 @@ export class Orchestrator {
     const host = new BuildCompilerHost(sys, this.fs, this.locale);
     const configOptions = config.options;
     const checkers = threads ? checkerThreads(configOptions.checkers, configOptions.singleThreaded) : 1;
-    if (checkers > 1 && parallelParse.spawn !== undefined) {
+    if (threads && configOptions.singleThreaded !== true && parallelParse.spawn !== undefined) {
       // Threads parse and bind the program's files ahead of it (parallel-parse.ts), as for plain
-      // compiles that check on threads. Here also when the program is checked on this thread, as
-      // after a change with old build info, whose program is parsed in full all the same. The
-      // program's FileLoader takes the files they prepared, and resolves their imports and
-      // references itself (`takesPreparedResolutions`): the build info lists the `package.json`
-      // files the program's module resolution looked up, and which ones it looks up depends on the
-      // order of its resolutions and on what its own caches hold. Declaration files that earlier
-      // projects of the build parsed come from the build's cache, and parse threads don't load
-      // them again.
+      // compiles. Here also when the program is checked on this thread, with one checker or after a
+      // change with old build info, whose program is parsed in full all the same. The
+      // program's FileLoader takes the files they prepared and the resolutions found loading them.
+      // Declaration files that earlier projects of the build parsed come from the build's cache,
+      // and parse threads don't load them again.
       const libraryDirectory = getNormalizedAbsolutePath(sys.defaultLibraryPath, sys.currentDirectory);
       const session = new ParseSession(
         parseThreads(checkers),
@@ -742,9 +739,15 @@ export class Orchestrator {
           buildSourceFileNames.has(kind === LoadKind.Library ? combinePaths(libraryDirectory, name) : name),
       );
       session.start(config.fileNames, () => {
-        const loader = new FileLoader(host, config);
-        loader.takesPreparedResolutions = false;
-        const program = new Program(config, host, loader);
+        // The program takes the resolutions the threads found, as `tsc -p` does, and is loaded
+        // again resolving every file itself only where their `package.json` lookups may miss some
+        // of its own (`hasAllPackageJsonLookups`), which the build info lists.
+        let program = new Program(config, host, new FileLoader(host, config));
+        if (!program.hasAllPackageJsonLookups()) {
+          const loader = new FileLoader(host, config);
+          loader.takesPreparedResolutions = false;
+          program = new Program(config, host, loader);
+        }
         reportPreparedFiles(program.getSourceFiles().map((f) => f.fileName));
         if (!this.checkAndEmit(task, program, parseStart, times, oldSnapshot, mayUseThreads, then)) then();
       });
@@ -824,7 +827,7 @@ export class Orchestrator {
       this.emitAndReport(task, checked, times, oldSnapshot, undefined, incrementalProgram);
       return false;
     }
-    const files = incrementalProgram.filesToCheck();
+    const files = incrementalProgram.filesForCheckers();
     if (!rechecksOnThreads(files, count, options.checkers !== undefined)) {
       this.emitAndReport(task, checked, times, oldSnapshot, undefined, incrementalProgram);
       return false;
@@ -839,6 +842,7 @@ export class Orchestrator {
       },
       true,
       incrementalProgram.emitKindsOnCheckers(files),
+      incrementalProgram.checksOnCheckers,
     );
     return true;
   }

package/src/compiler/tsc-cli.ts

@@ -18,7 +18,7 @@ import {
   type Locale,
   type MessageWithArgs,
 } from './diagnostics.js';
-import { CompilerHost, FileLoader } from './file-loader.js';
+import { CompilerHost, FileLoader, releaseLater } from './file-loader.js';
 import { CachedFileSystem, FileSystem, type DirectoryEntries } from './file-system.js';
 import { Program, sortAndDeduplicateDiagnostics } from './program.js';
 import { ConfigParser, ParsedCommandLine as ProjectConfig } from './tsconfig.js';
@@ -437,7 +437,7 @@ function executeCompile(sys: System, commandLine: ParsedCommandLine): CommandLin
             config.fileNames.length > 0,
           );
         // While the threads load files, the program's first step (a task per root file, which looks
-        // the file up) runs, and the tasks of the files they return are built ahead.
+        // the file up) runs, and the program's loader takes the files they return as they come.
         const host = new SystemCompilerHost(sys, fs, locale);
         const loader = new FileLoader(host, config);
         let rootFilesAdded = false;
@@ -447,7 +447,7 @@ function executeCompile(sys: System, commandLine: ParsedCommandLine): CommandLin
         const resolvesPackageJsons = config.configName !== '' && config.buildInfoFileName() !== '';
         session.onIdle = (batch) => {
           if (!rootFilesAdded) rootFilesAdded = loader.addRootFiles(rootFilesPerChunk);
-          loader.takeAhead(batch.files);
+          loader.walkAhead(batch.files);
           if (resolvesPackageJsons) {
             const lookups = batch.packageJsons;
             for (let k = 0; k < lookups.directories.length; k++)
@@ -471,6 +471,8 @@ function executeCompile(sys: System, commandLine: ParsedCommandLine): CommandLin
             result = createProgram(host, own);
           }
           done(result);
+          // The session's callbacks keep the loader: its tasks go once checking has started.
+          releaseLater(loader);
         });
         // The build info of an incremental program is read while the threads parse: reading it needs
         // only the config (compile and recheckInParallel, tsc-compile.ts, take it from here).
@@ -504,11 +506,12 @@ export const rootFilesPerChunk = 32;
 
 /**
  * Whether threads parse and bind the files of a program with `options` ahead of it (parallel-parse.ts):
- * where checker threads may be used. Also for an incremental program with build info, which is checked
- * on this thread (`checksIncrementalOnThreads`) but parsed in full all the same, as in build mode.
+ * unless `--singleThreaded` is given, as tsgo parses on every core whatever its checker count. Also with
+ * one checker, which checks on this thread, and for an incremental program with build info, whose
+ * program is parsed in full all the same, as in build mode.
  */
 function parsesAhead(options: CompilerOptions): boolean {
-  return checkerThreads(options.checkers, options.singleThreaded) > 1 && parallelParse.spawn !== undefined;
+  return options.singleThreaded !== true && parallelParse.spawn !== undefined;
 }
 
 /**

package/src/compiler/tsc-compile.ts

@@ -182,9 +182,10 @@ export function compileInParallel(
 /**
  * The rest of `compileInParallel` for an incremental program with build info: its program is shared with
  * the checker threads first, then the incremental program finds the files a change affects
- * (`IncrementalProgram.filesToCheck`); the threads check those when they are many enough to be worth it
- * (`rechecksOnThreads`), each emitting what the incremental program's emit would of the files it
- * checks (`emitKindsOnCheckers`), and this thread checks and emits them otherwise.
+ * and those whose outputs are pending (`IncrementalProgram.filesForCheckers`); the threads check those
+ * when they are many enough to be worth it (`rechecksOnThreads`), each emitting what the incremental
+ * program's emit would of the files it checks (`emitKindsOnCheckers`), and this thread checks and emits
+ * them otherwise.
  */
 function recheckInParallel(
   sys: System,
@@ -234,11 +235,18 @@ function recheckInParallel(
     incrementalProgram.getGlobalDiagnostics(false).length > 0
   )
     return finish();
-  const files = incrementalProgram.filesToCheck();
-  mark(`${files.length} files to check`);
+  const files = incrementalProgram.filesForCheckers();
+  mark(`${files.length} files to check or emit`);
   if (!rechecksOnThreads(files, threads, options.checkers !== undefined)) return finish();
   checked.checkOnly = new Set(files);
-  startParallelCheck(checked, threads, finish, true, incrementalProgram.emitKindsOnCheckers(files));
+  startParallelCheck(
+    checked,
+    threads,
+    finish,
+    true,
+    incrementalProgram.emitKindsOnCheckers(files),
+    incrementalProgram.checksOnCheckers,
+  );
 }
 
 /**
@@ -251,7 +259,8 @@ export function rechecksOnThreads(files: readonly SourceFile[], threads: number,
   if (files.length < 2 * threads) return false;
   if (checkersGiven) return true;
   let text = 0;
-  for (const file of files) text += file.text.length;
+  // A file's `end` is its text length (reading `text.length` scans a non-ASCII text in scriptc builds).
+  for (const file of files) text += file.end;
   return text >= recheckOnThreadsText;
 }
 

package/src/compiler/tsc-watch.ts

@@ -14,7 +14,7 @@ import {
   type MessageWithArgs,
 } from './diagnostics.js';
 import { type ExternalModuleIndicatorOptions, ParseOptions, ScriptKind, type SourceFile } from './ast.js';
-import { CompilerHost, FileLoader } from './file-loader.js';
+import { CompilerHost, FileLoader, releaseLater } from './file-loader.js';
 import { CachedFileSystem } from './file-system.js';
 import { clearLibGlobalsCache } from './checker-symbols.js';
 import { forgetLazyJSDocFile, parseSourceFile } from './parser.js';
@@ -162,6 +162,25 @@ class Stamps {
     return false;
   }
 
+  /**
+   * The files whose time stamps changed, or `undefined` when a watched directory's did: a file was added,
+   * removed or renamed there.
+   */
+  changedFiles(): string[] | undefined {
+    const files: string[] = [];
+    for (const [path, time] of this.times) {
+      if (this.sys.getMTime(path) === time) continue;
+      if (this.directories.has(path)) return undefined;
+      files.push(path);
+    }
+    return files;
+  }
+
+  /** Takes the current time stamps of `paths`. */
+  refresh(paths: readonly string[]): void {
+    for (const path of paths) if (this.times.has(path)) this.times.set(path, this.sys.getMTime(path));
+  }
+
   /**
    * Adds the directories whose events report changes of these paths: each directory, and each file's,
    * and for a file that is a symbolic link, its target's.
@@ -428,6 +447,8 @@ class Watcher {
    * (`computeLastSignatures`).
    */
   private lastChecked: CheckedProgram | undefined = undefined;
+  /** The program of the last build, which a rebuild updates when only the text of its files changed. */
+  private lastProgram: Program | undefined = undefined;
   /** Whether a rebuild is running (`poll`), and whether a check came during it. */
   private building = false;
   private checkPending = false;
@@ -519,10 +540,12 @@ class Watcher {
     let rootFilesAdded = false;
     session.onIdle = (batch) => {
       if (!rootFilesAdded) rootFilesAdded = loader.addRootFiles(rootFilesPerChunk);
-      loader.takeAhead(batch.files);
+      loader.walkAhead(batch.files);
     };
     session.start(config.fileNames, () => {
       const program = new Program(config, host, loader);
+      // The session's callbacks keep the loader: its tasks go once checking has started.
+      releaseLater(loader);
       this.files = this.files.next();
       for (const file of program.getSourceFiles()) {
         const indicator = file.externalModuleIndicatorOptions;
@@ -574,7 +597,7 @@ class Watcher {
     if (configChanged && !this.reloadConfig()) return done();
     if (this.configRead && watchRestart.restartsBeforeRebuild()) return done();
     this.status.report(Diagnostics.File_change_detected_Starting_incremental_compilation);
-    this.build(done);
+    this.build(done, configChanged ? undefined : this.stamps.changedFiles());
   }
 
   /** Rereads the config file; false (after reporting) if it can't be used. */
@@ -597,24 +620,31 @@ class Watcher {
     return true;
   }
 
-  /** Builds, on checker threads when the change affects many files, then calls `done`. */
-  private build(done: () => void): void {
+  /**
+   * Builds, on checker threads when the change affects many files, then calls `done`. `changedFiles` are
+   * the files whose time stamps changed, when no watched directory's and no config file's did.
+   */
+  private build(done: () => void, changedFiles?: readonly string[]): void {
     releaseProgramCaches();
     const sys = this.sys;
     const fs = new CachedFileSystem(new SystemFileSystem(sys));
-    if (this.config.configName !== '') {
-      // Pick up files added to or removed from included directories.
-      const parsed = new ConfigParser(fs, sys.currentDirectory).parseConfigFile(
-        this.config.configName,
-        this.commandLine.options,
-        this.commandLine.raw,
-        [],
-      );
-      if (parsed !== undefined) this.config = parsed;
+    let program = changedFiles !== undefined ? this.updatedProgram(changedFiles, fs) : undefined;
+    if (program === undefined) {
+      changedFiles = undefined;
+      if (this.config.configName !== '') {
+        // Pick up files added to or removed from included directories.
+        const parsed = new ConfigParser(fs, sys.currentDirectory).parseConfigFile(
+          this.config.configName,
+          this.commandLine.options,
+          this.commandLine.raw,
+          [],
+        );
+        if (parsed !== undefined) this.config = parsed;
+      }
+      this.files = this.files.next();
+      // A copy: a program shared with checker threads holds its config's errors (`copyCommandLine`).
+      program = new Program(copyCommandLine(this.config), new WatchCompilerHost(sys, fs, this.locale, this.files));
     }
-    this.files = this.files.next();
-    // A copy: a program shared with checker threads holds its config's errors (`copyCommandLine`).
-    const program = new Program(copyCommandLine(this.config), new WatchCompilerHost(sys, fs, this.locale, this.files));
     // The signatures the last build left as versions, for the files this one parsed.
     if (this.lastChecked !== undefined && this.snapshot !== undefined)
       computeLastSignatures(this.snapshot, this.lastChecked, this.files.parsed);
@@ -623,11 +653,36 @@ class Watcher {
     const signatures = new Map<string, string>();
     const threads = this.rebuildThreads(checked, signatures);
     // A new checker for checker threads: `rebuildThreads` may have emitted declarations with this one.
-    if (threads > 1) return this.recheckOnThreads(new CheckedProgram(program), threads, signatures, done);
-    this.finishBuild(checked, signatures);
+    if (threads > 1) return this.recheckOnThreads(new CheckedProgram(program), threads, signatures, done, changedFiles);
+    this.finishBuild(checked, signatures, changedFiles);
     done();
   }
 
+  /**
+   * The last build's program with `changedFiles` read again (`Program.updateFile`, as tsgo's watch swaps a
+   * changed file into its program), or `undefined` when one of them cannot be swapped in and the program
+   * must be loaded again. No directory and no config file changed, so the root files are the same. The
+   * source files of the updated program are those of the next build (`WatchSourceFiles`), which takes the
+   * unchanged ones without reading them.
+   */
+  private updatedProgram(changedFiles: readonly string[], fs: CachedFileSystem): Program | undefined {
+    let program = this.lastProgram;
+    if (program === undefined) return undefined;
+    const files = this.files.next();
+    const host = new WatchCompilerHost(this.sys, fs, this.locale, files);
+    for (const fileName of changedFiles) {
+      const file = program.getSourceFile(fileName);
+      if (file === undefined) return undefined;
+      program = program.updateFile(file.path, host);
+      if (program === undefined) return undefined;
+    }
+    for (const file of program.getSourceFiles())
+      files.current.set(watchFileKey(file.fileName, file.path, file.externalModuleIndicatorOptions), file);
+    this.files = files;
+    mark(`program updated, ${changedFiles.length} files`);
+    return program;
+  }
+
   /**
    * The checker threads for a rebuild of `checked`, or 1 to check it on this thread: threads where the
    * change may affect enough files for them (`rechecksOnThreads`), counting each changed file and every
@@ -696,6 +751,7 @@ class Watcher {
     threads: number,
     signatures: ReadonlyMap<string, string>,
     done: () => void,
+    changedFiles?: readonly string[],
   ): void {
     const sys = this.sys;
     const program = checked.program;
@@ -714,14 +770,14 @@ class Watcher {
       if (rechecksOnThreads(files, threads, options.checkers !== undefined)) {
         checked.checkOnly = new Set(files);
         const finish = (): void => {
-          this.report(incremental);
+          this.report(incremental, changedFiles);
           done();
         };
         startParallelCheck(checked, threads, finish, true, incremental.emitKindsOnCheckers(files));
         return;
       }
     }
-    this.report(incremental);
+    this.report(incremental, changedFiles);
     done();
   }
 
@@ -729,13 +785,23 @@ class Watcher {
    * Checks (where checker threads didn't), emits and reports `checked`, and watches its inputs. `signatures`
    * are the shape signatures computed for `checked`'s files before (`rebuildThreads`).
    */
-  private finishBuild(checked: CheckedProgram, signatures?: ReadonlyMap<string, string>): void {
+  private finishBuild(
+    checked: CheckedProgram,
+    signatures?: ReadonlyMap<string, string>,
+    changedFiles?: readonly string[],
+  ): void {
     const times = new CompileTimes();
-    this.report(new IncrementalProgram(checked, times, this.snapshot, new SystemTimeStamps(this.sys), signatures));
+    this.report(
+      new IncrementalProgram(checked, times, this.snapshot, new SystemTimeStamps(this.sys), signatures),
+      changedFiles,
+    );
   }
 
-  /** Checks (where checker threads didn't), emits and reports `incremental`, and watches its inputs. */
-  private report(incremental: IncrementalProgram): void {
+  /**
+   * Checks (where checker threads didn't), emits and reports `incremental`, and watches its inputs: those of a
+   * program `updatedProgram` made are the last build's, with new time stamps for `changedFiles`.
+   */
+  private report(incremental: IncrementalProgram, changedFiles?: readonly string[]): void {
     const sys = this.sys;
     const program = incremental.program;
     const result = emitFilesAndReportErrors(
@@ -748,7 +814,9 @@ class Watcher {
     );
     this.snapshot = incremental.snapshot;
     this.lastChecked = incremental.checked;
-    this.watchInputs(program);
+    this.lastProgram = program;
+    if (changedFiles !== undefined) this.stamps.refresh(changedFiles);
+    else this.watchInputs(program);
     this.status.reportErrorCount(result.diagnostics.length);
   }
 

package/src/compiler/tsconfig.ts

@@ -22,6 +22,7 @@ import {
   StringLiteral,
   type Node,
   type SourceFile,
+  propertyAssignmentPostfixToken,
 } from './ast.js';
 import { enumNamesList } from './command-line.js';
 import {
@@ -868,7 +869,7 @@ class ConfigFileConverter {
         this.errors.push(diagnosticAtRange(this.file, element, Diagnostics.Property_assignment_expected));
         continue;
       }
-      const postfix = element.postfixToken;
+      const postfix = propertyAssignmentPostfixToken(element);
       if (postfix !== undefined && postfix.kind === SyntaxKind.QuestionToken) {
         this.errors.push(
           diagnosticAtRange(this.file, postfix, Diagnostics.The_0_modifier_can_only_be_used_in_TypeScript_files, '?'),