tsc-ts 0.0.10 → 0.1.0

package/src/compiler/transformers/runtime-syntax.ts

@@ -56,6 +56,7 @@ import {
 import type { EmitResolver } from './emit-resolver.js';
 import { ConstantKind, type Evaluation } from './reference-resolver.js';
 import { type TypeScriptFacts } from './subtree-facts.js';
+import { nodeIsDecorated } from './decorator-utilities.js';
 import { Transformer } from './transformer.js';
 import {
   getInnermostModuleDeclaration,
@@ -65,6 +66,7 @@ import {
   isInstantiatedModule,
   isParameterPropertyDeclaration,
   isSameNode,
+  modifierFlagsOf,
 } from './utilities.js';
 
 const typeScriptModifiers =
@@ -577,7 +579,10 @@ export class RuntimeSyntax extends Transformer {
     let name = visitedName instanceof Identifier ? (visitedName as Identifier) : undefined;
     if (
       name === undefined &&
-      (exported || childIsDecorated(this.options.experimentalDecorators === true, node.members))
+      (exported ||
+        childIsDecorated(this.options.experimentalDecorators === true, node.members) ||
+        ((modifierFlagsOf(node) & exportDefault) !== exportDefault &&
+          nodeIsDecorated(this.options.experimentalDecorators === true, node, undefined, undefined)))
     )
       name = this.factory.createGeneratedNameForNode(node, 0, '', '');
     const updated: Node = this.factory.updateClassDeclaration(

package/src/compiler/transformers/syntax-facts.ts

@@ -4,7 +4,6 @@ import {
   BinaryExpression,
   BindingElement,
   BindingPattern,
-  CallExpression,
   CatchClause,
   ForInOrOfStatement,
   FunctionDeclaration,
@@ -29,6 +28,7 @@ import {
 import { ClusteredIntLinkTable } from '../link-tables.js';
 import { isTypeNodeKind } from '../printer/utilities.js';
 import { SyntaxKind } from '../syntax-kind.js';
+import { isImportCall } from '../ast-utilities.js';
 import { TokenFlags } from '../types.js';
 import { getElementsOfBindingOrAssignmentPattern, getTargetOfBindingOrAssignmentElement } from './destructuring.js';
 
@@ -267,12 +267,7 @@ export class SyntaxFacts extends NodeVisitor {
             : SubtreeFacts.None)
         );
       case SyntaxKind.CallExpression:
-        return (
-          this.children(node) |
-          (node instanceof CallExpression && node.expression.kind === SyntaxKind.ImportKeyword
-            ? SubtreeFacts.ContainsDynamicImport
-            : SubtreeFacts.None)
-        );
+        return this.children(node) | (isImportCall(node) ? SubtreeFacts.ContainsDynamicImport : SubtreeFacts.None);
       case SyntaxKind.MetaProperty:
         return node instanceof MetaProperty ? this.propagate(node.name) & ~SubtreeFacts.ContainsIdentifier : 0;
       case SyntaxKind.SpreadElement:

package/src/compiler/transformers/type-eraser.ts

@@ -398,7 +398,16 @@ export class TypeEraser extends Transformer {
       case SyntaxKind.ImportClause:
         if (node instanceof ImportClause) {
           if (node.phaseModifier === SyntaxKind.TypeKeyword) return undefined;
-          const bindings = this.visitNode(node.namedBindings);
+          let bindings = this.visitNode(node.namedBindings);
+          // With a default import, `{}` left by erasing type-only specifiers goes; a `{}` written in the source stays.
+          if (
+            node.name !== undefined &&
+            bindings instanceof NamedImports &&
+            bindings.elements.nodes.length === 0 &&
+            node.namedBindings instanceof NamedImports &&
+            node.namedBindings.elements.nodes.length !== 0
+          )
+            bindings = undefined;
           if (node.name === undefined && bindings === undefined) return undefined;
           return factory.updateImportClause(node, node.phaseModifier, node.name, bindings);
         }

package/src/compiler/transformers/type-serialization.ts

@@ -22,6 +22,7 @@ import {
   UnionTypeNode,
   VariableDeclaration,
   getIsTypeOnly,
+  getText,
 } from '../ast.js';
 import { getStrictOptionValue } from '../options.js';
 import { SyntaxKind } from '../syntax-kind.js';
@@ -119,10 +120,10 @@ function resolveEntityName(
     const namespace = resolveEntityName(resolver, name.left, SymbolFlags.Namespace, false, location);
     if (namespace === undefined) return undefined;
     if (namespace === unknownSymbol) return namespace;
-    let member = resolver.getExportOfSymbol(namespace, name.right.text);
+    let member = resolver.getExportOfSymbol(namespace, getText(name.right));
     if (member === undefined && (namespace.flags & SymbolFlags.Alias) !== 0) {
       const target = resolver.resolveAlias(namespace);
-      if (target !== undefined) member = resolver.getExportOfSymbol(target, name.right.text);
+      if (target !== undefined) member = resolver.getExportOfSymbol(target, getText(name.right));
     }
     if (member === undefined || (member.flags & (meaning | SymbolFlags.Alias)) === 0) return undefined;
     symbol = member;

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

@@ -1186,6 +1186,7 @@ export abstract class VisitorBase extends VisitorHooks {
             this.visitModifiers(node.modifiers),
             node.keyword,
             required(this.visitNode(node.name), node.name),
+            this.visitNode(node.attributes) as TypeLiteralNode | undefined,
             this.visitNode(node.body),
           );
         break;
@@ -1340,7 +1341,7 @@ export abstract class VisitorBase extends VisitorHooks {
           return this.factory.updateQualifiedName(
             node,
             required(this.visitNode(node.left), node.left),
-            asIdentifier(this.visitNode(node.right), node.right),
+            required(this.visitNode(node.right), node.right),
           );
         break;
       case SyntaxKind.RestType:

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

@@ -144,11 +144,16 @@ export abstract class VisitorHooks {
     if (declarations.length === 0) return updated;
     const factory = this.factory;
     if (updated === undefined) return factory.createBlock(declarations, true);
-    if (!(updated instanceof Block))
-      return factory.createBlock(
-        this.context.mergeEnvironment([factory.createReturnStatement(updated)], declarations),
-        false,
+    if (!(updated instanceof Block)) {
+      // The return statement takes the expression's range, so its comments are emitted once, before `return`.
+      this.context.addEmitFlags(updated, EmitFlags.NoComments);
+      const block = this.context.convertToFunctionBlock(updated, false);
+      return factory.updateBlock(
+        block,
+        this.context.mergeEnvironmentList(block.statements, declarations),
+        block.multiLine,
       );
+    }
     return factory.updateBlock(
       updated,
       this.context.mergeEnvironmentList(updated.statements, declarations),

package/src/compiler/tsc-build.ts

@@ -777,6 +777,9 @@ export class Orchestrator {
     times.parseTime = performance.now() - parseStart;
     const bindStart = performance.now();
     const checked = new CheckedProgram(program);
+    // The project's incremental program, made after checking, keeps the globals found checking a file
+    // with the file.
+    checked.globalsInFileDiagnostics = true;
     times.bindTime = performance.now() - bindStart;
     const options = program.options;
     const count = mayUseThreads ? checkerThreads(options.checkers, options.singleThreaded, program) : 1;

package/src/compiler/tsc-cli.ts

@@ -64,6 +64,8 @@ export abstract class System extends CommandLineHost {
 
   /** Returns `''` for unset variables. */
   abstract getEnvironmentVariable(name: string): string;
+  /** Whether the variable is set, perhaps to `''`. */
+  abstract hasEnvironmentVariable(name: string): boolean;
   abstract write(text: string): void;
   abstract fileExists(path: string): boolean;
   abstract directoryExists(path: string): boolean;

package/src/compiler/tsc-compile.ts

@@ -8,6 +8,7 @@ import {
   CheckedProgram,
   CompilerProgram,
   CompileTimes,
+  declarationDiagnosticsDue,
   getDiagnosticsOfProgram,
   OutputWriter,
   PlainProgram,
@@ -320,6 +321,8 @@ export function compileWithDeclarationThread(
   let declaring = true;
   const report = (): void => {
     if (diagnostics === undefined || declaring) return;
+    if (declarationDiagnosticsDue(compilerProgram, diagnostics, false))
+      for (const d of compilerProgram.getDeclarationDiagnostics()) diagnostics.push(d);
     const result = reportEmitAndErrors(
       sys,
       compilerProgram,
@@ -338,7 +341,7 @@ export function compileWithDeclarationThread(
     declaring = false;
     report();
   });
-  // `PlainProgram.emit` reports the declaration errors once the thread has found them.
+  // `report` adds the declaration errors once the thread has found them, when they are due.
   diagnostics = getDiagnosticsOfProgram(compilerProgram, false, true);
   mark('diagnostics collected');
   report();
@@ -364,6 +367,8 @@ export function compileInParallel(
   formattedReports.format = work.reporter.plainFormat();
   mark(`${threads} checkers`);
   const checked = new CheckedProgram(program);
+  // The incremental program made after checking keeps the globals found checking a file with the file.
+  if (work.incremental) checked.globalsInFileDiagnostics = true;
   times.bindTime = performance.now() - bindStart;
   mark('checker created');
   if (work.incremental && !checksIncrementalOnThreads(sys, program.commandLine.buildInfoFileName())) {
@@ -565,7 +570,7 @@ export function reportEmitAndErrors(
   if (program.options.listFilesOnly !== true) {
     const emitStart = performance.now();
     emitResult = program.emit(writer);
-    program.times.emitTime = performance.now() - emitStart;
+    program.times.emitTime += performance.now() - emitStart;
   }
   for (const diagnostic of emitResult.diagnostics) diagnostics.push(diagnostic);
   const all = sortAndDeduplicateDiagnostics(diagnostics);

package/src/compiler/tsc-watch.ts

@@ -474,14 +474,6 @@ class Watcher {
 
   start(): void {
     const sys = this.sys;
-    if (this.config.options.incremental === true || this.config.options.composite === true) {
-      this.snapshot = readBuildInfoProgram(
-        this.config,
-        new FileBuildInfoReader(new SystemFileSystem(sys)),
-        sys.defaultLibraryPath,
-        sys.currentDirectory,
-      );
-    }
     this.status.report(
       watchRestart.resumed
         ? Diagnostics.File_change_detected_Starting_incremental_compilation
@@ -491,59 +483,86 @@ class Watcher {
       watchRestart.firstBuildDone();
       this.changes.watch([this.stamps, this.configStamps]);
     };
-    // A program shared with checker threads is never written: symbols get their ids when created.
     const options = this.config.options;
-    if (parallelParse.spawn !== undefined && checkerThreads(options.checkers, options.singleThreaded) > 1)
+    if (parallelParse.spawn !== undefined && options.singleThreaded !== true) {
+      // Parse threads load the first program, as they load a compile's (`parsesAhead`, tsc-cli.ts), and
+      // it is shared with them: its symbols get their ids when they are created.
       assignSymbolIdsAtCreation();
-    const threads = this.firstBuildThreads();
-    if (threads > 1) this.buildOnThreads(threads, watchChanges);
-    else this.build(watchChanges);
-  }
-
-  /**
-   * The checker threads of the first build: those of a compile (`compileThreads`), or 1 to build on this
-   * thread. A first build without old state checks every file, as a compile does; rebuilds check what a
-   * change affects (`rebuildThreads`). With build info (`--incremental`), the first build stays here.
-   */
-  private firstBuildThreads(): number {
-    const options = this.config.options;
-    if (this.snapshot !== undefined || isIncremental(options) || parallelParse.spawn === undefined) return 1;
-    return checkerThreads(options.checkers, options.singleThreaded);
+      this.buildOnThreads(watchChanges);
+      return;
+    }
+    if (isIncremental(options))
+      this.snapshot = readBuildInfoProgram(
+        this.config,
+        new FileBuildInfoReader(new SystemFileSystem(sys)),
+        sys.defaultLibraryPath,
+        sys.currentDirectory,
+      );
+    this.build(watchChanges);
   }
 
   /**
-   * Builds the first program as a compile does: parse threads load its files, and checker threads check
-   * it (parallel-check.ts) unless it checks little. The program is shared with them, so it gets its own
-   * copy of the config and a host of its own. Its files go to the watch's file maps for rebuilds to take,
-   * and are never written again: rebuilds check them with the checker's side tables. Calls `done` once
-   * the build is reported.
+   * Builds the first program as a compile does: parse threads load its files while this thread reads the
+   * build info (`--incremental`), and checker threads check it (parallel-check.ts) unless it checks little.
+   * Without old state, every file is checked, as a compile does; with build info, the files the changes
+   * since affect are, as a rebuild checks them (`recheckOnThreads`). The program is shared with the
+   * threads, so it gets its own copy of the config and a host of its own. Its files go to the watch's
+   * file maps for rebuilds to take, and are never written again: rebuilds check them with the checker's
+   * side tables. Calls `done` once the build is reported.
    */
-  private buildOnThreads(threads: number, done: () => void): void {
+  private buildOnThreads(done: () => void): void {
     releaseProgramCaches();
     const sys = this.sys;
     const config = copyCommandLine(this.config);
     const options = config.options;
+    const incremental = isIncremental(options);
     const session = new ParseSession(
-      parseThreads(threads),
+      parseThreads(checkerThreads(options.checkers, options.singleThreaded)),
       options,
       sys.currentDirectory,
       config.configName,
       config.fileNames.length > 0,
     );
-    const host = new WatchCompilerHost(
-      sys,
-      new CachedFileSystem(new SystemFileSystem(sys)),
-      this.locale,
-      new WatchSourceFiles(),
-    );
+    const fs = new CachedFileSystem(new SystemFileSystem(sys));
+    const host = new WatchCompilerHost(sys, fs, this.locale, new WatchSourceFiles());
     const loader = new FileLoader(host, config);
     let rootFilesAdded = false;
+    // The build info lists the real paths of the `package.json` files module resolution looked up, as
+    // a compile's does (tsc-cli.ts): those of the threads' lookups are resolved into the file system's cache.
+    const resolvesPackageJsons = incremental && config.configName !== '' && config.buildInfoFileName() !== '';
     session.onIdle = (batch) => {
       if (!rootFilesAdded) rootFilesAdded = loader.addRootFiles(rootFilesPerChunk);
       loader.walkAhead(batch.files);
+      if (resolvesPackageJsons) {
+        const lookups = batch.packageJsons;
+        for (let k = 0; k < lookups.directories.length; k++)
+          if (lookups.exists[k]! || lookups.directoryExists[k]!)
+            fs.realpath(combinePaths(lookups.directories[k]!, 'package.json'));
+      }
+    };
+    // The build info is read while the threads parse, as a compile reads it, or here if they are done first.
+    let buildInfoRead = !incremental;
+    const readBuildInfo = (): void => {
+      if (buildInfoRead) return;
+      buildInfoRead = true;
+      this.snapshot = readBuildInfoProgram(
+        config,
+        new FileBuildInfoReader(new SystemFileSystem(sys)),
+        sys.defaultLibraryPath,
+        sys.currentDirectory,
+      );
+      mark('build info read');
     };
     session.start(config.fileNames, () => {
-      const program = new Program(config, host, loader);
+      readBuildInfo();
+      let program = new Program(config, host, loader);
+      // Where the threads' lookups may miss some `package.json` files of the build info, the program is
+      // loaded again, resolving every file's imports and references itself, as a compile does.
+      if (incremental && !program.hasAllPackageJsonLookups()) {
+        const own = new FileLoader(host, config);
+        own.takesPreparedResolutions = false;
+        program = new Program(config, host, own);
+      }
       // The session's callbacks keep the loader: its tasks go once checking has started.
       releaseLater(loader);
       this.files = this.files.next();
@@ -552,16 +571,25 @@ class Watcher {
         this.files.current.set(watchFileKey(file.fileName, file.path, indicator), file);
       }
       const checked = new CheckedProgram(program);
+      // The incremental program `finishBuild` makes after checking keeps the globals found checking a file
+      // with the file.
+      checked.globalsInFileDiagnostics = true;
       const finish = (): void => {
-        this.finishBuild(checked);
         // Rebuilds parse what changed themselves.
         clearPreparedFiles();
         done();
       };
-      const count = checkerThreads(options.checkers, options.singleThreaded, program);
-      if (count > 1) startParallelCheck(checked, count, finish);
-      else finish();
+      const threads = checkerThreads(options.checkers, options.singleThreaded, program);
+      if (this.snapshot !== undefined && threads > 1) return this.recheckOnThreads(checked, threads, new Map(), finish);
+      const report = (): void => {
+        this.finishBuild(checked);
+        finish();
+      };
+      if (this.snapshot === undefined && threads > 1) startParallelCheck(checked, threads, report);
+      else report();
     });
+    if (incremental && sys.fileExists(config.buildInfoFileName())) session.queueAhead();
+    readBuildInfo();
   }
 
   private configFiles(): string[] {
@@ -650,6 +678,7 @@ class Watcher {
       computeLastSignatures(this.snapshot, this.lastChecked, this.files.parsed);
     this.lastChecked = undefined;
     const checked = new CheckedProgram(program);
+    checked.globalsInFileDiagnostics = true;
     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.
@@ -690,9 +719,9 @@ class Watcher {
    * affects the global scope. A changed file whose declaration file keeps the signature of the last
    * build affects only itself (`getFilesAffectedBy`); its signature is computed with `checked`'s checker
    * and added to `signatures`. That is what the change affects at most; `recheckOnThreads` then takes
-   * what it does affect. A watch whose first config kept it on one thread gave its symbols no ids at
-   * creation (`start`), so its rebuilds, which take the unchanged files of earlier builds, stay on this
-   * thread after a config edit turns checker threads on.
+   * what it does affect. A watch that started without parse threads (`--singleThreaded`) gave its symbols
+   * no ids at creation (`start`), so its rebuilds, which take the unchanged files of earlier builds, stay on
+   * this thread after a config edit turns checker threads on.
    */
   private rebuildThreads(checked: CheckedProgram, signatures: Map<string, string>): number {
     const program = checked.program;