tsc-ts 0.1.0 → 0.1.1

package/src/compiler/decoder.ts

@@ -201,6 +201,7 @@ import {
 import { modifiersToFlags } from './ast-utilities.js';
 import { protocolVersion } from './encoder.js';
 import { SyntaxKind } from './syntax-kind.js';
+import { IdentifierName } from './identifier-name.js';
 
 const nodeSize = 28;
 const headerSize = 64;
@@ -354,7 +355,7 @@ class Decoder {
   createString(kind: SyntaxKind, text: string, common: number): Node {
     switch (kind) {
       case SyntaxKind.Identifier:
-        return new Identifier(text);
+        return new Identifier(new IdentifierName(text));
       case SyntaxKind.PrivateIdentifier:
         return new PrivateIdentifier(text);
       case SyntaxKind.JsxText:

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/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/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/jsdoc.ts

@@ -57,6 +57,7 @@ import { Reparser } from './reparser.js';
 import { getLeadingCommentRanges, getTrailingCommentRanges } from './scanner.js';
 import { SyntaxKind } from './syntax-kind.js';
 import type { CommentRange } from './types.js';
+import { IdentifierName } from './identifier-name.js';
 
 const enum JSDocState {
   BeginningOfLine,
@@ -1230,16 +1231,17 @@ export class JSDocParser {
         p.parseErrorAtCurrentToken(Diagnostics.Identifier_expected_0_is_a_reserved_word_that_cannot_be_used_here, [
           p.scanner.getTokenText(),
         ]);
-      const missing = p.newIdentifier('');
+      const missing = p.newIdentifier(new IdentifierName(''));
       p.finishNode(missing, p.nodePos());
       return missing;
     }
     const pos = p.scanner.getTokenStart();
     const end = p.scanner.getTokenEnd();
     const text = p.scanner.getIdentifierValue();
+    const name = p.scanner.getIdentifierName();
     p.internIdentifier(text);
     p.nextTokenJSDoc();
-    const result = p.newIdentifier(text);
+    const result = p.newIdentifier(name);
     p.finishNodeWithEnd(result, pos, end);
     return result;
   }