tsc-ts 0.0.10 → 0.1.1

package/src/compiler/transformers/reference-resolver.ts

@@ -527,26 +527,45 @@ export class ReferenceResolver {
     const moduleDeclaration = moduleDeclarationOfSpecifier(declaration);
     if (imported === undefined || moduleDeclaration === undefined) return false;
     const moduleSymbol = this.resolveModuleSpecifier(declaration, getModuleSpecifierOf(moduleDeclaration));
-    return moduleSymbol !== undefined && this.isExportedThroughTypeOnlyStar(moduleSymbol, imported, new Set<Symbol>());
+    return moduleSymbol !== undefined && this.isExportedThroughTypeOnlyStar(moduleSymbol, imported);
   }
 
-  /** Whether a module's export `name` comes from another module through an `export type *` on the way. */
-  private isExportedThroughTypeOnlyStar(moduleSymbol: Symbol, name: string, visited: Set<Symbol>): boolean {
-    if (visited.has(moduleSymbol)) return false;
-    visited.add(moduleSymbol);
-    const exports = moduleSymbol.exports;
-    if (exports === undefined || exports.has(name) || name === InternalSymbolName.Default) return false;
+  /**
+   * Whether a module's export `name` comes from another module through an `export type *`, as tsgo's
+   * getExportsOfModuleWorker decides: a module reached through a type-only `export *` has its exports marked, and a
+   * module reached without one, even if already visited, clears the mark of its own exports.
+   */
+  private isExportedThroughTypeOnlyStar(moduleSymbol: Symbol, name: string): boolean {
+    if (name === InternalSymbolName.Default) return false;
+    const walk = new TypeOnlyStarWalk(name);
+    this.visitExportStars(walk, moduleSymbol, false, false);
+    return walk.typeOnly && !walk.nonTypeOnly;
+  }
+
+  /** Visits a module of an `export *` walk; returns whether it exports the walk's name. */
+  private visitExportStars(
+    walk: TypeOnlyStarWalk,
+    symbol: Symbol | undefined,
+    starIsTypeOnly: boolean,
+    isTypeOnly: boolean,
+  ): boolean {
+    const exports = symbol === undefined ? undefined : symbol.exports;
+    if (!isTypeOnly && exports !== undefined && exports.has(walk.name)) walk.nonTypeOnly = true;
+    if (symbol === undefined || exports === undefined || walk.visited.has(symbol)) return false;
+    walk.visited.add(symbol);
+    let found = exports.has(walk.name);
     const star = exports.get(InternalSymbolName.ExportStar);
-    if (star === undefined) return false;
-    for (const declaration of getDeclarations(star)) {
-      if (!(declaration instanceof ExportDeclaration)) continue;
-      const target = this.resolveExternalModuleSymbol(
-        this.resolveModuleSpecifier(declaration, declaration.moduleSpecifier),
-      );
-      if (target === undefined || this.getExportFromTable(target, name, new Set<Symbol>()) === undefined) continue;
-      return declaration.isTypeOnly || this.isExportedThroughTypeOnlyStar(target, name, visited);
-    }
-    return false;
+    if (star !== undefined)
+      for (const declaration of getDeclarations(star)) {
+        if (!(declaration instanceof ExportDeclaration)) continue;
+        const target = this.resolveExternalModuleSymbol(
+          this.resolveModuleSpecifier(declaration, declaration.moduleSpecifier),
+        );
+        if (this.visitExportStars(walk, target, declaration.isTypeOnly, isTypeOnly || declaration.isTypeOnly))
+          found = true;
+      }
+    if (starIsTypeOnly && found) walk.typeOnly = true;
+    return found;
   }
 
   /** Whether a symbol is declared in the global scope. */
@@ -803,6 +822,34 @@ export class ReferenceResolver {
 
   // Constant values
 
+  /**
+   * The symbol an entity name expression such as `E.A` refers to as an expression: tsgo takes the symbol its checker
+   * resolves the expression to, where each name on the left is a value, so a local `let E` hides a const enum `E`.
+   */
+  private resolveValueEntityName(name: Node): Symbol | undefined {
+    let symbol: Symbol | undefined;
+    if (name instanceof Identifier) {
+      const resolved = this.resolveName(name, name.text, SymbolFlags.Value | SymbolFlags.Alias);
+      symbol = resolved === undefined ? undefined : this.getMergedSymbol(resolved);
+    } else if (name instanceof PropertyAccessExpression) {
+      const left = this.resolveValueEntityName(name.expression);
+      const right = name.name;
+      if (left === undefined || !(right instanceof Identifier)) return undefined;
+      let member = left.exports === undefined ? undefined : left.exports.get(right.text);
+      // A namespace merged with an alias also has the members of what the alias names, as its type does.
+      if (member === undefined && (left.flags & SymbolFlags.Alias) !== 0) {
+        const target = this.resolveAlias(left);
+        const targetExports = target === undefined ? undefined : target.exports;
+        if (targetExports !== undefined) member = targetExports.get(right.text);
+      }
+      if (member === undefined || (member.flags & (SymbolFlags.Value | SymbolFlags.Alias)) === 0) return undefined;
+      symbol = this.getMergedSymbol(member);
+    } else return undefined;
+    if (symbol === undefined || (symbol.flags & SymbolFlags.Alias) === 0) return symbol;
+    const target = this.resolveAlias(symbol);
+    return target === undefined ? undefined : this.getMergedSymbol(target);
+  }
+
   /** The value of an enum member, computing the values of its whole declaration. */
   getEnumMemberValue(member: Node): Evaluation {
     const declaration = member.parent;
@@ -816,11 +863,11 @@ export class ReferenceResolver {
     if (node instanceof EnumMember) return this.getEnumMemberValue(node);
     let symbol: Symbol | undefined;
     if (node instanceof PropertyAccessExpression) {
-      if (isEntityNameExpressionNode(node)) symbol = this.resolveEntityName(node, SymbolFlags.Value, false);
+      if (isEntityNameExpressionNode(node)) symbol = this.resolveValueEntityName(node);
     } else if (node instanceof ElementAccessExpression) {
       const argument = stringLiteralText(node.argumentExpression);
       if (isEntityNameExpressionNode(node.expression) && argument !== undefined) {
-        const root = this.resolveEntityName(node.expression, SymbolFlags.Value, false);
+        const root = this.resolveValueEntityName(node.expression);
         const exports = root === undefined ? undefined : root.exports;
         const member = exports === undefined ? undefined : exports.get(argument);
         if (member !== undefined) symbol = this.getMergedSymbol(member);
@@ -1131,6 +1178,23 @@ export function getDeclarationOfAliasSymbol(symbol: Symbol): Node | undefined {
   return undefined;
 }
 
+/** The state of `isExportedThroughTypeOnlyStar`'s walk over the `export *` declarations of modules for one name. */
+class TypeOnlyStarWalk {
+  readonly name: string;
+  readonly visited: Set<Symbol>;
+  /** Whether a module reached through a type-only `export *` exports the name. */
+  typeOnly: boolean;
+  /** Whether a module reached without one exports the name itself. */
+  nonTypeOnly: boolean;
+
+  constructor(name: string) {
+    this.name = name;
+    this.visited = new Set<Symbol>();
+    this.typeOnly = false;
+    this.nonTypeOnly = false;
+  }
+}
+
 function isTypeOnlyAlias(symbol: Symbol): boolean {
   let node = getDeclarationOfAliasSymbol(symbol);
   while (node !== undefined) {

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

@@ -62,12 +62,15 @@ import {
   exitStatusOf,
   rechecksOnThreads,
   reportEmitAndErrors,
+  saveRunRecord,
   Statistics,
   statisticsOf,
   SystemTimeStamps,
 } from './tsc-compile.js';
 import { sharesPublishedGraphs } from '@scriptc/threads';
-import { checkerThreads, parseThreads, shareWithCheckers, startParallelCheck } from './parallel-check.js';
+import { checkerThreads, shareWithCheckers, startParallelCheck } from './parallel-check.js';
+import { preParseConfig, reportRunConfig, type RunConfig } from './run-config.js';
+import { openRecord } from './run-record-read.js';
 import { emitThreads } from './parallel-emit.js';
 import { LoadKind, ParseSession, clearPreparedFiles, parallelParse, reportPreparedFiles } from './parallel-parse.js';
 import { assignSymbolIdsAtCreation } from './symbol.js';
@@ -182,6 +185,8 @@ class BuildTask {
   buildKind = BuildKind.None;
   filesToDelete: string[] = [];
   configTime = 0;
+  /** The project's run configuration (run-config.ts), one per project of the build. */
+  run: RunConfig | undefined = undefined;
 
   constructor(readonly config: string) {}
 }
@@ -726,6 +731,33 @@ 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;
+    // The projects of a build that builds several at once run beside each other, and each one's timings
+    // are the machine's, not its own: none keeps a record (run-records.ts). A watcher's builds measure a
+    // change, not the project: they keep none either, and read none.
+    const builders = this.command.buildOptions.builders ?? (configOptions.singleThreaded === true ? 1 : 4);
+    const learning = builders === 1 && !this.watching;
+    const opened = learning
+      ? openRecord({
+          configFile: configOptions.configFilePath ?? task.config,
+          rootNames: config.fileNames,
+          options: configOptions,
+        })
+      : undefined;
+    // One configuration per project: its parse threads, and the pins of its checker count and sharing.
+    const run = (task.run = preParseConfig(configOptions, checkers, process.env, opened?.record, learning));
+    if (opened !== undefined) {
+      run.recordDirectory = opened.directory;
+      run.recordKey = opened.key;
+      run.recordFile = opened.file;
+    }
+    if (builders > 1) {
+      run.records = false;
+      run.recordsReason = 'concurrent projects';
+    }
+    if (this.watching) {
+      run.records = false;
+      run.recordsReason = 'watch mode';
+    }
     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. Here also when the program is checked on this thread, with one checker or after a
@@ -735,7 +767,7 @@ export class Orchestrator {
       // and parse threads don't load them again.
       const libraryDirectory = getNormalizedAbsolutePath(sys.defaultLibraryPath, sys.currentDirectory);
       const session = new ParseSession(
-        parseThreads(checkers),
+        run.parseThreads,
         configOptions,
         sys.currentDirectory,
         task.config,
@@ -777,9 +809,21 @@ 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;
+    // The run's configuration reports the count that checks: a checker thread run decides again once
+    // the plan is made (`startParallelCheck`, run-config.ts).
+    if (task.run !== undefined) task.run.checkers = count;
+    // A project rebuilt on its old build info checks the files a change affects, not the project: it
+    // keeps no sample, which records only keep full checks of (`run-records.ts`).
+    if (task.run !== undefined && oldSnapshot !== undefined && isIncremental(options)) {
+      task.run.records = false;
+      task.run.recordsReason = 'incremental recheck';
+    }
     if (count > 1 && oldSnapshot !== undefined) {
       if (isIncremental(options)) return this.recheckOnThreads(task, checked, times, oldSnapshot, count, then);
       // Build info of a project that is no longer incremental has no pending emit to give the threads,
@@ -791,10 +835,20 @@ export class Orchestrator {
     if (count > 1) {
       // Checker threads also emit the files they check; the incremental program records their
       // declaration signatures on this thread.
-      startParallelCheck(checked, count, (checkTime) => {
-        this.emitAndReport(task, checked, times, oldSnapshot, checkTime);
-        then();
-      });
+      startParallelCheck(
+        checked,
+        count,
+        (checkTime) => {
+          this.emitAndReport(task, checked, times, oldSnapshot, checkTime);
+          then();
+        },
+        true,
+        undefined,
+        true,
+        undefined,
+        undefined,
+        task.run,
+      );
       return true;
     }
     if (mayUseThreads && this.emitsOnThreads(checked, oldSnapshot))
@@ -896,6 +950,9 @@ export class Orchestrator {
       true,
       incrementalProgram.emitKindsOnCheckers(files),
       incrementalProgram.checksOnCheckers,
+      undefined,
+      undefined,
+      task.run,
     );
     return true;
   }
@@ -942,10 +999,14 @@ export class Orchestrator {
     task.exitStatus = exitStatusOf(result);
     if (parallelCheckTime !== undefined) times.checkTime = parallelCheckTime;
     const options = program.options;
+    // A project's sample is kept whether or not the build reports statistics, and the section reports
+    // where it went (`run-records.ts`).
+    const records = saveRunRecord(sys, incrementalProgram, task.run);
     if (options.diagnostics === true || options.extendedDiagnostics === true) {
       times.totalTime = sys.sinceStart();
       const statistics = statisticsOf(incrementalProgram);
       statistics.report(sys);
+      if (options.extendedDiagnostics === true && task.run !== undefined) reportRunConfig(sys, task.run, records);
       task.statistics = statistics;
     }
     const status = task.status;

package/src/compiler/tsc-cli.ts

@@ -33,8 +33,10 @@ import { Colors, defaultIsPretty, header, printBuildHelp, printHelp, printVersio
 import { generateTSConfig } from './init.js';
 import { isIncremental, type CompilerOptions } from './options.js';
 import { combinePaths, getDirectoryPath, normalizePath } from './path.js';
-import { checkerThreads, parseThreads } from './parallel-check.js';
+import { checkerThreads } from './parallel-check.js';
 import { ParseSession, parallelParse, reportPreparedFiles } from './parallel-parse.js';
+import { preParseConfig, type RunConfig } from './run-config.js';
+import { openRecord } from './run-record-read.js';
 import { showConfig, type ShowConfigInput } from './show-config.js';
 import { assignSymbolIdsAtCreation } from './symbol.js';
 import { sharesPublishedGraphs } from '@scriptc/threads';
@@ -64,6 +66,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;
@@ -161,6 +165,8 @@ export type CommandLineResult =
       readonly errorSummary: ErrorSummaryReporter;
       /** The build info of an incremental program, read while threads parsed its files; `undefined` if not read yet. */
       readonly buildInfo?: EarlyBuildInfo;
+      /** How the run is configured: parse threads, checker count and sharing (run-config.ts). */
+      readonly config: RunConfig;
     }
   /** Threads are preparing the program's files; `run` calls back with the result once they are done. */
   | { readonly kind: 'deferred'; readonly run: (done: (result: CommandLineResult) => void) => void }
@@ -361,6 +367,31 @@ function executeCompile(sys: System, commandLine: ParsedCommandLine): CommandLin
   const configStart = performance.now();
   mark('config start');
   const errors: Diagnostic[] = [];
+  // The run's configuration, made once the config's options are known: its parse threads are needed
+  // before the first file is parsed.
+  let run: RunConfig | undefined = undefined;
+  const runConfigOf = (projectOptions: CompilerOptions): RunConfig => {
+    if (run === undefined) {
+      const opened = openRecord({
+        configFile: projectOptions.configFilePath ?? (configFileName === '' ? undefined : configFileName),
+        rootNames: fileNames,
+        options: projectOptions,
+      });
+      const made = preParseConfig(
+        projectOptions,
+        checkerThreads(projectOptions.checkers, projectOptions.singleThreaded),
+        process.env,
+        opened?.record,
+      );
+      if (opened !== undefined) {
+        made.recordDirectory = opened.directory;
+        made.recordKey = opened.key;
+        made.recordFile = opened.file;
+      }
+      run = made;
+    }
+    return run;
+  };
   // Where threads parse and bind the program's files ahead of it (parallel-parse.ts), they start with
   // the libraries and the root files found so far while the config's `include` patterns are matched.
   let session: ParseSession | undefined = undefined;
@@ -368,7 +399,7 @@ function executeCompile(sys: System, commandLine: ParsedCommandLine): CommandLin
     if (projectOptions.watch === true || options.showConfig === true || !parsesAhead(projectOptions)) return undefined;
     assignSymbolIdsAtCreation();
     const started = new ParseSession(
-      parseThreads(checkerThreads(projectOptions.checkers, projectOptions.singleThreaded)),
+      runConfigOf(projectOptions).parseThreads,
       projectOptions,
       sys.currentDirectory,
       configFileName,
@@ -422,20 +453,20 @@ function executeCompile(sys: System, commandLine: ParsedCommandLine): CommandLin
       reporter,
       errorSummary,
       buildInfo,
+      config: runConfigOf(config.options),
     };
   };
   if (parsesAhead(config.options)) {
     // Threads parse and bind the files the program is expected to load first (parallel-parse.ts), and
     // share the program it becomes: its symbols get their ids when they are created.
     assignSymbolIdsAtCreation();
-    const threads = checkerThreads(config.options.checkers, config.options.singleThreaded);
     return {
       kind: 'deferred',
       run: (done: (result: CommandLineResult) => void) => {
         const session =
           early ??
           new ParseSession(
-            parseThreads(threads),
+            runConfigOf(config.options).parseThreads,
             config.options,
             sys.currentDirectory,
             configFileName,