tsc-ts 0.0.10 → 0.1.1

package/src/compiler/doctor-report.ts

@@ -0,0 +1,133 @@
+/**
+ * The report a `tsc-ts doctor` child writes: `TSC_TS_DOCTOR_REPORT` names a file, and `main.ts` writes
+ * what the child's compile measured to it before the process exits. The doctor process reads the file
+ * after the child exits; its own runs are unaffected, since nothing here is set for them.
+ *
+ * The parent times the child and compares its diagnostic output itself, so the report carries what only
+ * the child knows: the phase times, the program's shape, the signals, the run's configuration and the
+ * key the run's record would have.
+ */
+import { writeFileSync } from 'node:fs';
+import { residentMB } from './parallel-check.js';
+
+/** The report path, or `undefined` when this process is not a doctor child. */
+export function doctorReportPath(): string | undefined {
+  const path = process.env.TSC_TS_DOCTOR_REPORT;
+  return path === undefined || path === '' ? undefined : path;
+}
+
+/** What a bound program showed about the cost of checking it (`CheckSignals`), as the report keeps it. */
+export interface DoctorSignals {
+  count: number;
+  ranges: number;
+  library: number;
+  own: number;
+  redundancy: number;
+  declarationShare: number;
+  nodeModulesShare: number;
+  fileShare: number;
+}
+
+/** The program's size, as a run record keeps it. */
+export interface DoctorShape {
+  files: number;
+  chars: number;
+  declarationChars: number;
+  checkChars: number;
+}
+
+/** The phase times of a compile, in milliseconds (`CompileTimes`). */
+export interface DoctorTimes {
+  parseMs: number;
+  checkMs: number;
+  totalMs: number;
+}
+
+/** What this child's compile measured. */
+export interface DoctorCompile {
+  /** The version the executable reports (`help.ts`). */
+  version: string;
+  /** The project's config file, or `undefined` for root files on the command line. */
+  configFile: string | undefined;
+  /** The key a record of this run would have (`run-records.ts`). */
+  key: string;
+  checkers: number;
+  share: boolean;
+  parseThreads: number;
+  times: DoctorTimes;
+  shape: DoctorShape;
+  signals: DoctorSignals | undefined;
+}
+
+/**
+ * What the file holds: the compile the child measured, where it measured one, plus the exit status,
+ * the CPU time and the peak memory. A child that never compiled writes only the last three.
+ */
+export interface DoctorReport {
+  version?: string;
+  configFile?: string;
+  key?: string;
+  checkers?: number;
+  share?: boolean;
+  parseThreads?: number;
+  times?: DoctorTimes;
+  shape?: DoctorShape;
+  signals?: DoctorSignals;
+  status: number;
+  cpuMs: number;
+  peakMB: number;
+}
+
+/** The report the process writes, once its compile measured something. */
+let pending: DoctorCompile | undefined;
+
+/** Records what this child's compile measured; `main.ts` writes it before the process exits. */
+export function setDoctorCompile(compile: DoctorCompile): void {
+  pending = compile;
+}
+
+/**
+ * Exits with `status`, writing the doctor report first where `TSC_TS_DOCTOR_REPORT` names a file. The
+ * compile's exits go through here: the thread drivers in `node-system.ts` exit from their callbacks,
+ * without returning to `main.ts`.
+ */
+export function exitWithDoctorReport(status: number): never {
+  if (doctorReportPath() !== undefined) {
+    const cpu = process.cpuUsage();
+    writeDoctorReport(status, (cpu.user + cpu.system) / 1000);
+  }
+  return process.exit(status);
+}
+
+/**
+ * Writes the report to the file `TSC_TS_DOCTOR_REPORT` names, with the exit status, the CPU time and the
+ * peak memory read at exit. Never throws: a report that cannot be written leaves the parent to time the
+ * child without one.
+ */
+export function writeDoctorReport(status: number, cpuMs: number): void {
+  const path = doctorReportPath();
+  if (path === undefined) return;
+  const compile = pending;
+  const report: DoctorReport =
+    compile === undefined
+      ? { status, cpuMs, peakMB: residentMB()[1] }
+      : {
+          version: compile.version,
+          configFile: compile.configFile,
+          key: compile.key,
+          checkers: compile.checkers,
+          share: compile.share,
+          parseThreads: compile.parseThreads,
+          times: compile.times,
+          shape: compile.shape,
+          signals: compile.signals,
+          status,
+          cpuMs,
+          peakMB: residentMB()[1],
+        };
+  try {
+    writeFileSync(path, JSON.stringify(report) + '\n');
+  } catch {
+    // The parent reports the run without a report file.
+  }
+}

package/src/compiler/emitter.ts

@@ -1,7 +1,7 @@
 // Emits JavaScript and declarations for source files: runs the transforms, prints, and writes
 // the output, source map and `//# sourceMappingURL` comment.
 import { ScriptKind, type SourceFile } from './ast.js';
-import { compareDiagnostics, type Diagnostic } from './diagnostics.js';
+import { compareDiagnostics, equalDiagnostics, type Diagnostic } from './diagnostics.js';
 import { type CompilerOptions, JsxEmit, NewLineKind, getEmitScriptTarget, getIsolatedModules } from './options.js';
 import { LanguageVariant } from './types.js';
 import { type OutputPathsHost, getOutputPathsFor } from './output-paths.js';
@@ -33,7 +33,7 @@ import { RuntimeSyntax } from './transformers/runtime-syntax.js';
 import { ConstEnumInliner } from './transformers/const-enum-inliner.js';
 import { addDownlevelTransformers } from './transformers/downlevel.js';
 import { JsxTransformer } from './transformers/jsx.js';
-import { SyntaxFacts } from './transformers/syntax-facts.js';
+import { SubtreeFacts, SyntaxFacts } from './transformers/syntax-facts.js';
 import { LegacyDecorators } from './transformers/legacy-decorators.js';
 import { DecoratorMetadata } from './transformers/decorator-metadata.js';
 
@@ -143,6 +143,12 @@ export const enum EmitOnly {
    * signature of incremental builds; it is written with its errors and without a map.
    */
   ForcedDts,
+  /**
+   * The declaration file of a file whose JavaScript this build emits in a separate request, such as on another
+   * thread. tsgo emits both with one emit context, so the emit flags its JavaScript transforms set on the file's
+   * own nodes also apply to its declarations; this replays those transforms first.
+   */
+  DtsAfterJs,
 }
 
 export function emitFiles(host: EmitHost, files: readonly SourceFile[], emitOnly: EmitOnly = EmitOnly.All): EmitResult {
@@ -157,21 +163,44 @@ export function emitFiles(host: EmitHost, files: readonly SourceFile[], emitOnly
     const file = files[i];
     if (!sourceFileMayBeEmitted(file, options) || host.isSourceFileFromExternalLibrary(file)) continue;
     const paths = getOutputPathsFor(file.fileName, file.scriptKind === ScriptKind.JSON, options, host, forced);
+    // As in tsgo, a file's JavaScript and declarations share one emit context: emit flags that JavaScript
+    // transforms set on the file's own nodes, such as a decorated parameter's name, also apply to its declarations.
+    const context = new EmitContext();
     if (paths.jsFilePath !== '' && (emitOnly === EmitOnly.All || emitOnly === EmitOnly.Js)) {
       if (host.isEmitBlocked(paths.jsFilePath)) result.emitSkipped = true;
-      else emitJSFile(host, file, paths.jsFilePath, paths.sourceMapFilePath, result);
+      else emitJSFile(host, context, file, paths.jsFilePath, paths.sourceMapFilePath, result);
     }
     if (paths.declarationFilePath !== '' && emitOnly !== EmitOnly.Js) {
       if (!forced && host.isEmitBlocked(paths.declarationFilePath)) result.emitSkipped = true;
-      else emitDeclarationFile(host, file, paths.declarationFilePath, paths.declarationMapPath, result, forced);
+      else {
+        if (emitOnly === EmitOnly.DtsAfterJs && paths.jsFilePath !== '') replayScriptTransforms(host, context, file);
+        emitDeclarationFile(host, context, file, paths.declarationFilePath, paths.declarationMapPath, result, forced);
+      }
     }
   }
   return result;
 }
 
+/**
+ * Runs the JavaScript transforms of `file` in `context` without printing, for the emit flags they set on the
+ * file's own nodes. Only the decorator transforms set any that declaration emit prints (on decorated parameters'
+ * names), so files without decorators are skipped.
+ */
+function replayScriptTransforms(host: EmitHost, context: EmitContext, file: SourceFile): void {
+  if (!new SyntaxFacts().has(file, SubtreeFacts.ContainsDecorators)) return;
+  let transformed = file;
+  const transformers = getScriptTransformers(host, context, file);
+  for (let i = 0; i < transformers.length; i++) {
+    const transformer = transformers[i];
+    if (transformer.unsupported !== '') return;
+    transformed = transformer.transformSourceFile(transformed);
+  }
+}
+
 /** Emits a declaration file; the host's resolver must be a `DeclarationEmitResolver`. */
 function emitDeclarationFile(
   host: EmitHost,
+  context: EmitContext,
   file: SourceFile,
   declarationFilePath: string,
   declarationMapPath: string,
@@ -184,7 +213,6 @@ function emitDeclarationFile(
     return false;
   }
   const options = host.options;
-  const context = new EmitContext();
   const transformer = new DeclarationTransformer(context, host, options, resolver, declarationFilePath);
   const transformed = transformer.transformSourceFile(file);
   result.declarationTransformed = true;
@@ -214,11 +242,32 @@ function emitDeclarationFile(
     emitSourceMaps,
     false,
     result,
-    // Sorted, as tsgo's emitter diagnostics are; the order is part of the file's signature in build info.
-    diagnostics.length > 1 ? diagnostics.toSorted(compareDiagnostics) : diagnostics,
+    emitterDiagnostics(diagnostics),
   );
 }
 
+/**
+ * Declaration diagnostics as tsgo's emitter collects them: sorted, without repeats of an equal
+ * diagnostic. They are part of the file's signature in build info.
+ */
+function emitterDiagnostics(diagnostics: readonly Diagnostic[]): readonly Diagnostic[] {
+  if (diagnostics.length < 2) return diagnostics;
+  const sorted = diagnostics.toSorted(compareDiagnostics);
+  const result: Diagnostic[] = [];
+  for (const diagnostic of sorted) {
+    // Equal diagnostics compare as 0, so a repeat is among the last ones kept that compare as 0.
+    let repeated = false;
+    for (let i = result.length - 1; i >= 0 && compareDiagnostics(result[i], diagnostic) === 0; i--) {
+      if (equalDiagnostics(result[i], diagnostic)) {
+        repeated = true;
+        break;
+      }
+    }
+    if (!repeated) result.push(diagnostic);
+  }
+  return result;
+}
+
 function getScriptTransformers(host: EmitHost, context: EmitContext, file: SourceFile): Transformer[] {
   const options = host.options;
   const facts = new TypeScriptFacts();
@@ -248,13 +297,13 @@ function isJsxTransformEnabled(options: CompilerOptions): boolean {
 
 function emitJSFile(
   host: EmitHost,
+  context: EmitContext,
   file: SourceFile,
   jsFilePath: string,
   sourceMapFilePath: string,
   result: EmitResult,
 ): boolean {
   const options = host.options;
-  const context = new EmitContext();
   let transformed = file;
   const transformers = getScriptTransformers(host, context, file);
   for (let i = 0; i < transformers.length; i++) {

package/src/compiler/encoder.ts

@@ -1,7 +1,7 @@
-// Encodes a source file in TypeScript 7's binary AST format (protocol version 5), the
+// Encodes a source file in TypeScript 7.1's binary AST format (protocol version 9), the
 // `getSourceFile` payload of the API.
 //
-// Layout: a 44-byte header, string offsets (UTF-8 start/end pairs), string data (the
+// Layout: a 64-byte header, string offsets (UTF-8 start/end pairs), string data (the
 // UTF-8 file text, then strings that aren't slices of it), extended node data,
 // msgpack structured data, and 28-byte node records in visit order. Node positions are
 // UTF-16 offsets.
@@ -197,10 +197,10 @@ import { SyntaxKind } from './syntax-kind.js';
 import { hash128 } from './xxh3.js';
 import { utf8Offsets } from './character-codes.js';
 
-export const protocolVersion = 5;
+export const protocolVersion = 9;
 
 const nodeSize = 28;
-const headerSize = 44;
+const headerSize = 64;
 const nodeListKind = 0xffffffff;
 const noStructuredData = 0xffffffff;
 
@@ -210,6 +210,11 @@ const dataTypeExtended = 2 << 30;
 
 const utf8Encoder = new TextEncoder();
 
+/** A node list record's last word: 1 when the list ends with a comma. */
+function trailingComma(list: NodeList): number {
+  return list.hasTrailingComma() ? 1 : 0;
+}
+
 /** A growable little-endian byte buffer. */
 class ByteWriter {
   bytes: Uint8Array;
@@ -1261,7 +1266,8 @@ function childrenPropertyMask(node: Node): number {
       return node instanceof ModuleDeclaration
         ? (hasModifiers((node as ModuleDeclaration).modifiers) ? 1 : 0) |
             ((node as ModuleDeclaration).name !== undefined ? 2 : 0) |
-            ((node as ModuleDeclaration).body !== undefined ? 4 : 0)
+            ((node as ModuleDeclaration).attributes !== undefined ? 4 : 0) |
+            ((node as ModuleDeclaration).body !== undefined ? 8 : 0)
         : 0;
     case SyntaxKind.ImportEqualsDeclaration:
       return node instanceof ImportEqualsDeclaration
@@ -1381,6 +1387,7 @@ function commonData(node: Node): number {
       if (!(node instanceof ImportClause)) return 0;
       if ((node as ImportClause).phaseModifier === SyntaxKind.TypeKeyword) return 1 << 24;
       if ((node as ImportClause).phaseModifier === SyntaxKind.DeferKeyword) return 2 << 24;
+      if ((node as ImportClause).phaseModifier === SyntaxKind.SourceKeyword) return 3 << 24;
       return 0;
     case SyntaxKind.ImportSpecifier:
       return node instanceof ImportSpecifier ? bit((node as ImportSpecifier).isTypeOnly) << 24 : 0;
@@ -1577,7 +1584,7 @@ class Encoder extends NodeVisitor {
     this.linkSibling(index);
     const positions = this.positions;
     if (positions === undefined)
-      this.nodes.push(nodeListKind, list.pos, list.end, this.parentIndex, list.nodes.length, 0);
+      this.nodes.push(nodeListKind, list.pos, list.end, this.parentIndex, list.nodes.length, trailingComma(list));
     else
       this.nodes.push(
         nodeListKind,
@@ -1585,7 +1592,7 @@ class Encoder extends NodeVisitor {
         positions.of(list.end),
         this.parentIndex,
         list.nodes.length,
-        0,
+        trailingComma(list),
       );
     const saveParent = this.parentIndex;
     this.prevIndex = 0;
@@ -1659,6 +1666,8 @@ class Encoder extends NodeVisitor {
     out.u32(offsetExtended);
     out.u32(offsetStructured);
     out.u32(offsetNodes);
+    // Source file ID and lease ID (u64 each) and binder data offset: 0, none.
+    for (let i = 0; i < 5; i++) out.u32(0);
     out.append(strings.offsets.view());
     out.append(fileText);
     out.append(strings.others.view());
@@ -1787,7 +1796,8 @@ class Encoder extends NodeVisitor {
       );
       out.u32((node as TemplateTail).templateFlags);
     } else if (node instanceof SourceFile) {
-      out.u32(strings.addFileText((node as SourceFile).pos, (node as SourceFile).end));
+      const text = strings.addFileText((node as SourceFile).pos, (node as SourceFile).end);
+      out.u32(text);
       out.u32(strings.add((node as SourceFile).fileName, SyntaxKind.Unknown, 0, 0));
       out.u32(strings.add((node as SourceFile).path, SyntaxKind.Unknown, 0, 0));
       out.u32((node as SourceFile).languageVariant);
@@ -1801,6 +1811,11 @@ class Encoder extends NodeVisitor {
       out.u32(noStructuredData);
       out.u32(noStructuredData);
       out.u32(0);
+      // The original text is the text, and the content mapper fields (span map, supplemental
+      // file names, canonical file name, mapper, virtual file name, diagnostic directives) are
+      // empty: tsc-ts maps no file contents.
+      out.u32(text);
+      for (let i = 0; i < 6; i++) out.u32(noStructuredData);
     } else throw new Error(`no extended data for kind ${node.kind}`);
     return offset;
   }

package/src/compiler/expr-record.ts

@@ -0,0 +1,59 @@
+// The type the last completed check of an expression produced, by node and check mode, for the
+// expressions that are checked with no contextual type.
+//
+// The checker checks some expressions more than once with the same inputs: a body that the eager
+// pass reached and the deferred pass reaches again, a node re-checked after a loop body, an
+// argument of a second inference round. A check is a function of the node, the check mode and the
+// checker's state, and the state only grows while the checker runs, so a check that completed
+// earlier answers the next check of the same node: the later check would produce the type the
+// earlier one produced, report the diagnostics it reported and defer the nodes it deferred.
+//
+// A contextual type is part of the inputs, so the record can only serve an expression whose check
+// has none: the checker-contextual predicate says so before the record is consulted, and a check
+// under a contextual type never reads or writes the record. For the same reason the record is not
+// consulted while an inference context is in force: what the check infers into depends on it.
+//
+// The record is a direct-mapped table that stores the key beside the value, so a lookup that lands
+// on another node reads the entry as a miss. Its size bounds the memory and the cache the lookups
+// use: an entry is a node id, a mode and a type slot, the whole table takes about 200 KB, and 2^14
+// entries serve nearly all repeats (2^14 against 2^20 loses 0.1% of the check on the largest
+// program measured).
+
+import type { Type } from './checker-types.js';
+
+/** Entries in the record; a power of two. */
+const EntryCount = 1 << 14;
+const EntryMask = EntryCount - 1;
+
+/** The types by entry; a slot holds the type of the check recorded at that entry. */
+function newTypeSlots(): (Type | undefined)[] {
+  const slots: (Type | undefined)[] = [];
+  for (let i = 0; i < EntryCount; i++) slots.push(undefined);
+  return slots;
+}
+
+function entryOf(nodeId: number, mode: number): number {
+  return (Math.imul(nodeId, 0x9e3779b1) ^ mode) & EntryMask;
+}
+
+export class ExprCheckRecord {
+  /** The node id of the check at each entry, plus one; zero where no check is recorded. */
+  private readonly nodeIds = new Int32Array(EntryCount);
+  private readonly modes = new Uint8Array(EntryCount);
+  private readonly types = newTypeSlots();
+
+  /** The type the last completed check of the node under `mode` produced, if the entry holds it. */
+  get(nodeId: number, mode: number): Type | undefined {
+    const entry = entryOf(nodeId, mode);
+    if (this.nodeIds[entry] !== nodeId + 1 || this.modes[entry] !== mode) return undefined;
+    return this.types[entry];
+  }
+
+  /** Records that a check of the node under `mode` produced `type`. */
+  set(nodeId: number, mode: number, type: Type): void {
+    const entry = entryOf(nodeId, mode);
+    this.nodeIds[entry] = nodeId + 1;
+    this.modes[entry] = mode;
+    this.types[entry] = type;
+  }
+}

package/src/compiler/file-include.ts

@@ -597,10 +597,16 @@ export class IncludeProcessor {
     return this.fileIncludeReasons.get(path) ?? [];
   }
 
-  addReason(path: string, reason: FileIncludeReason): void {
+  /** Adds an include reason of the file at `path`; returns the file's reasons. */
+  addReason(path: string, reason: FileIncludeReason): FileIncludeReason[] {
     const reasons = this.fileIncludeReasons.get(path);
-    if (reasons === undefined) this.fileIncludeReasons.set(path, [reason]);
-    else reasons.push(reason);
+    if (reasons === undefined) {
+      const added = [reason];
+      this.fileIncludeReasons.set(path, added);
+      return added;
+    }
+    reasons.push(reason);
+    return reasons;
   }
 
   addProcessingDiagnostic(diagnostic: ProcessingDiagnostic): void {