tsc-ts 0.1.0 → 0.1.2

package/dist/api/compiler/transformers/declarations.js

@@ -14,6 +14,7 @@ import { DiagnosticContext, canProduceDiagnostics, createDiagnosticForNode, decl
 import { DeclarationTracker } from './declarations-tracker.js';
 import { Transformer } from './transformer.js';
 import { declarationCount, getDeclarations } from '../symbol.js';
+import { IdentifierName } from '../identifier-name.js';
 export class DeclarationTransformer extends Transformer {
     host;
     options;
@@ -1357,7 +1358,7 @@ export class DeclarationTransformer extends Transformer {
                 keyword === 79 /* SyntaxKind.Identifier */ ||
                 keyword === 89 /* SyntaxKind.DefaultKeyword */) {
                 // A parse tree node, so names it uses are resolved where it's written.
-                const identifier = new Identifier(text);
+                const identifier = new Identifier(new IdentifierName(text));
                 identifier.parent = name.parent;
                 return identifier;
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tsc-ts",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "The TypeScript 7 compiler, ported to TypeScript and compiled to a native executable.",
   "license": "Apache-2.0",
   "repository": {
@@ -28,19 +28,24 @@
     },
     "./package.json": "./package.json"
   },
-  "dependencies": {
-    "@scriptc/threads": "0.4.7"
+  "peerDependencies": {
+    "@scriptc/threads": "0.4.8"
+  },
+  "peerDependenciesMeta": {
+    "@scriptc/threads": {
+      "optional": true
+    }
   },
   "engines": {
     "node": ">=20"
   },
   "optionalDependencies": {
-    "@tsc-ts/darwin-arm64": "0.1.0",
-    "@tsc-ts/darwin-x64": "0.1.0",
-    "@tsc-ts/linux-arm64-gnu": "0.1.0",
-    "@tsc-ts/linux-arm64-musl": "0.1.0",
-    "@tsc-ts/linux-x64-gnu": "0.1.0",
-    "@tsc-ts/linux-x64-musl": "0.1.0",
-    "@tsc-ts/win32-x64-msvc": "0.1.0"
+    "@tsc-ts/darwin-arm64": "0.1.2",
+    "@tsc-ts/darwin-x64": "0.1.2",
+    "@tsc-ts/linux-arm64-gnu": "0.1.2",
+    "@tsc-ts/linux-arm64-musl": "0.1.2",
+    "@tsc-ts/linux-x64-gnu": "0.1.2",
+    "@tsc-ts/linux-x64-musl": "0.1.2",
+    "@tsc-ts/win32-x64-msvc": "0.1.2"
   }
 }

package/src/compiler/ast.ts

@@ -3,6 +3,7 @@
 // Every node extends `Node`. Child fields are typed by category (`Expression`, `TypeNode`, …),
 // which are aliases of `Node`; narrow with the `is*` guards in ast-utilities.ts or `instanceof`.
 import type { ProgramLifetime } from '@scriptc/types';
+import { IdentifierName } from './identifier-name.js';
 import { SyntaxKind } from './syntax-kind.js';
 import { type CommentDirective, type CommentRange, type LanguageVariant, TokenFlags } from './types.js';
 import { type Diagnostic, DiagnosticFile } from './diagnostics.js';
@@ -208,9 +209,14 @@ export abstract class NodeVisitor {
   }
 }
 
-// Native builds store `pos`, `end` and `id` as 32-bit integers when every write provably stores an
-// int32, so writes of values the compiler can't bound (parameters, the id counter) are coerced
-// with `| 0`; the values are always int32.
+// Native builds store `pos`, `end` and `id` as 32-bit integers when every write provably stores
+// an int32, so writes of values the compiler can't bound (parameters, the id counter) are
+// coerced with `| 0`; the values are always int32.
+//
+// The fields of a node that the public API's node types declare are stored fields, not values
+// computed from or packed into another field: a native build copies the stored fields of a node
+// into a record when API code narrows one (`node as StringLiteralLike`), and a field behind an
+// accessor is not copied.
 export abstract class Node implements ProgramLifetime {
   readonly kind: SyntaxKind;
   flags: NodeFlags;
@@ -449,11 +455,15 @@ export class Token extends Node {
 }
 
 export class Identifier extends Node {
-  text: string;
+  readonly identifierName: IdentifierName;
 
-  constructor(text: string) {
+  constructor(name: IdentifierName) {
     super(SyntaxKind.Identifier);
-    this.text = text;
+    this.identifierName = name;
+  }
+
+  get text(): string {
+    return this.identifierName.text;
   }
 
   forEachChild(_v: NodeVisitor): boolean {
@@ -467,7 +477,7 @@ export class Identifier extends Node {
   }
 
   copy(): Identifier {
-    const node = new Identifier(this.text);
+    const node = new Identifier(this.identifierName);
     node.flags = this.flags;
     node.pos = this.pos;
     node.end = this.end;
@@ -484,13 +494,13 @@ export class ReferenceIdentifier extends Identifier {
   // Set by the binder.
   flowNode: FlowNode | undefined;
 
-  constructor(text: string) {
-    super(text);
+  constructor(name: IdentifierName) {
+    super(name);
     this.flowNode = undefined;
   }
 
   copy(): Identifier {
-    const node = new ReferenceIdentifier(this.text);
+    const node = new ReferenceIdentifier(this.identifierName);
     node.flags = this.flags;
     node.pos = this.pos;
     node.end = this.end;
@@ -8239,6 +8249,7 @@ export const emptyCommentDirectives: readonly CommentDirective[] = [];
 export const emptyPragmas: readonly Pragma[] = [];
 export const emptyFileReferences: readonly FileReference[] = [];
 export const emptyPatternAmbientModules: readonly PatternAmbientModule[] = [];
+const emptyNumbers: readonly number[] = [];
 
 /** `list` with `item` appended: a new array when `list` is empty (it may be shared), else `list` itself. */
 export function appendToList<T>(list: readonly T[], item: T): readonly T[] {
@@ -8315,6 +8326,14 @@ export class SourceFile extends Node {
   /** UMD exports from `export as namespace N`. */
   globalExports: SymbolTable | undefined;
 
+  // Set by the grammar checks of a parse thread (checker-grammar.ts).
+  /** The diagnostics the parse thread's grammar walk reported for this file. */
+  grammarDiagnostics: Diagnostic[] | undefined;
+  /** The nodes of this file whose grammar check needs the checker, in tree order. */
+  grammarResidualNodes: Node[] | undefined;
+  /** The blocks and statements that reported a statement in an ambient context. */
+  grammarAmbientReports: readonly number[];
+
   constructor(
     fileName: string,
     path: string,
@@ -8368,6 +8387,9 @@ export class SourceFile extends Node {
     this.symbolCount = 0;
     this.patternAmbientModules = emptyPatternAmbientModules;
     this.globalExports = undefined;
+    this.grammarDiagnostics = undefined;
+    this.grammarResidualNodes = undefined;
+    this.grammarAmbientReports = emptyNumbers;
   }
 
   forEachChild(v: NodeVisitor): boolean {
@@ -8417,20 +8439,22 @@ export class PatternAmbientModule {
   readonly text: string;
   readonly starIndex: number;
   readonly symbol: Symbol;
+  /** The part of `text` before `starIndex`, kept so a match does not copy it. */
+  readonly prefix: string;
+  /** The part of `text` after `starIndex`, kept so a match does not copy it. */
+  readonly suffix: string;
 
   constructor(text: string, starIndex: number, symbol: Symbol) {
     this.text = text;
     this.starIndex = starIndex;
     this.symbol = symbol;
+    this.prefix = text.substring(0, starIndex);
+    this.suffix = text.substring(starIndex + 1);
   }
 
   matches(candidate: string): boolean {
-    const text = this.text;
-    const star = this.starIndex;
     return (
-      candidate.length >= text.length - 1 &&
-      candidate.startsWith(text.substring(0, star)) &&
-      candidate.endsWith(text.substring(star + 1))
+      candidate.length >= this.text.length - 1 && candidate.startsWith(this.prefix) && candidate.endsWith(this.suffix)
     );
   }
 }

package/src/compiler/cgroup.ts

@@ -0,0 +1,157 @@
+// The limits the process's cgroup puts on the machine a run sees: the whole CPUs its CPU quota allows
+// and the smallest memory limit of its cgroup and that cgroup's ancestors. `os.availableParallelism()`
+// already lowers its count to a quota of one CPU or more; the native runtime's count ignores a quota
+// below one, which truncates to no CPUs there and falls back to the affinity mask, so the quota is read
+// here too. The memory limit only sometimes reaches `process.constrainedMemory()` (libuv reads the
+// process's own cgroup, and scriptc's runtime only the root of the cgroup mount, which is the process's
+// own cgroup only inside a cgroup namespace).
+import { readFileSync } from 'node:fs';
+import { availableParallelism } from 'node:os';
+
+/**
+ * The CPUs this process may run on: `os.availableParallelism()`, lowered to the whole CPUs its cgroup
+ * quota allows (`cgroupCpuQuota`). Where the runtime already applies the quota this returns the same
+ * count; a quota below one CPU, which the native runtime's count ignores, lowers it to one. The text and
+ * root parameters are for the tests.
+ */
+export function availableCpus(membershipText: string = readMembership(), root: string = '/sys/fs/cgroup'): number {
+  const cpus = Math.max(1, availableParallelism());
+  const quota = cgroupCpuQuota(membershipText, root);
+  return quota > 0 && quota < cpus ? quota : cpus;
+}
+
+/**
+ * The whole CPUs this process's cgroup and its ancestors allow, or 0 where there is none or it is
+ * unknown: `cpu.max` under cgroup v2, `cpu.cfs_quota_us` and `cpu.cfs_period_us` under v1. A quota
+ * below one CPU counts as one, the least a run can use. The text and root parameters are for the tests.
+ */
+export function cgroupCpuQuota(membershipText: string = readMembership(), root: string = '/sys/fs/cgroup'): number {
+  let quota = 0;
+  const lower = (value: number): void => {
+    if (value > 0 && (quota === 0 || value < quota)) quota = value;
+  };
+  forEachCgroupDirectory(membershipText, root, '', (directory) => {
+    lower(cpuMaxValue(directory + '/cpu.max'));
+  });
+  forEachCgroupDirectory(membershipText, root, 'cpu', (directory) => {
+    // The kernel's default period, for a mount that lost the file but kept its quota.
+    const period = numberIn(directory + '/cpu.cfs_period_us') || 100_000;
+    lower(wholeCpus(numberIn(directory + '/cpu.cfs_quota_us'), period));
+  });
+  return quota;
+}
+
+/**
+ * The smallest memory limit of this process's cgroup and its ancestors (Linux), or 0 where there is
+ * none or it is unknown: `memory.max` and `memory.high` under cgroup v2, `memory.limit_in_bytes` under
+ * v1. The text and root parameters are for the tests.
+ */
+export function cgroupMemoryLimit(membershipText: string = readMembership(), root: string = '/sys/fs/cgroup'): number {
+  let limit = 0;
+  const lower = (value: number): void => {
+    if (value > 0 && (limit === 0 || value < limit)) limit = value;
+  };
+  forEachCgroupDirectory(membershipText, root, '', (directory) => {
+    lower(memoryLimitValue(directory + '/memory.max'));
+    lower(memoryLimitValue(directory + '/memory.high'));
+  });
+  forEachCgroupDirectory(membershipText, root, 'memory', (directory) => {
+    lower(memoryLimitValue(directory + '/memory.limit_in_bytes'));
+  });
+  return limit;
+}
+
+/**
+ * Calls `visit` with the directory of this process's cgroup for `controller` and of each of its
+ * ancestors, deepest first: the unified hierarchy for `''` (cgroup v2, whose line lists no
+ * controllers), or the controller's own mount for a v1 line that lists it.
+ */
+function forEachCgroupDirectory(
+  membershipText: string,
+  root: string,
+  controller: string,
+  visit: (directory: string) => void,
+): void {
+  for (const line of membershipText.split('\n')) {
+    // "0::/path" (v2), "N:cpu:/path" or "N:cpu,cpuacct:/path" (v1).
+    const first = line.indexOf(':');
+    const second = line.indexOf(':', first + 1);
+    if (first < 0 || second < 0) continue;
+    const controllers = line.substring(first + 1, second);
+    const path = line.substring(second + 1);
+    if (controller === '') {
+      if (controllers !== '') continue;
+      forEachAncestor(path, (directory) => visit(root + directory));
+    } else if (controllers.split(',').indexOf(controller) >= 0) {
+      forEachAncestor(path, (directory) => visit(root + '/' + controller + directory));
+    }
+  }
+}
+
+/**
+ * Calls `visit` with `path` and each of its ancestors, deepest first ("/a/b/c", "/a/b", "/a", ""): a
+ * cgroup's limits apply to every process below it, in cgroup v1 as in v2.
+ */
+function forEachAncestor(path: string, visit: (directory: string) => void): void {
+  for (let directory = path; ; directory = directory.substring(0, directory.lastIndexOf('/'))) {
+    visit(directory === '/' ? '' : directory);
+    if (directory === '' || directory.lastIndexOf('/') < 0) break;
+  }
+}
+
+/** `/proc/self/cgroup`, or an empty text where it cannot be read (no cgroup limits). */
+function readMembership(): string {
+  try {
+    return readFileSync('/proc/self/cgroup', 'utf8');
+  } catch {
+    return '';
+  }
+}
+
+/**
+ * The whole CPUs a cgroup v2 quota file allows, or 0 for `max`, an unreadable file or no number:
+ * `cpu.max` holds "MAX PERIOD" in microseconds.
+ */
+function cpuMaxValue(file: string): number {
+  let text: string;
+  try {
+    text = readFileSync(file, 'utf8').trim();
+  } catch {
+    return 0;
+  }
+  if (text === '' || text === 'max') return 0;
+  const parts = text.split(/\s+/).map(Number);
+  return wholeCpus(parts[0]!, parts[1] ?? 100_000);
+}
+
+/** A cgroup memory limit file's value in bytes, or 0 for `max`, an unreadable file or no number. */
+function memoryLimitValue(file: string): number {
+  let text: string;
+  try {
+    text = readFileSync(file, 'utf8').trim();
+  } catch {
+    return 0;
+  }
+  if (text === '' || text === 'max') return 0;
+  const value = Number(text);
+  // cgroup v1 reports no limit as a page-aligned value near 2^63.
+  return Number.isFinite(value) && value > 0 && value < 2 ** 62 ? value : 0;
+}
+
+/** A file's number, or 0 where it cannot be read or holds none (a v1 quota of -1 is no quota). */
+function numberIn(file: string): number {
+  let text: string;
+  try {
+    text = readFileSync(file, 'utf8').trim();
+  } catch {
+    return 0;
+  }
+  const value = Number(text);
+  return Number.isFinite(value) && value > 0 ? value : 0;
+}
+
+/** The whole CPUs `quota` microseconds per `period` microseconds allow, at least one where there is one. */
+function wholeCpus(quota: number, period: number): number {
+  if (!Number.isFinite(quota) || !Number.isFinite(period) || quota <= 0 || period <= 0) return 0;
+  return Math.max(1, Math.floor(quota / period));
+}

package/src/compiler/checker-classes.ts

@@ -107,6 +107,7 @@ import {
 } from './checker-heritage.js';
 import { checkDecorators, getFirstTransformableStaticClassElement } from './checker-decorators.js';
 import { getTypeOfNode } from './checker-services.js';
+import { IdentifierName } from './identifier-name.js';
 
 export function checkClassDeclaration(c: Checker, node: Node): void {
   checkClassLikeDeclaration(c, node);
@@ -588,7 +589,7 @@ function newThisPropertyReference(symbol: Symbol, container: Node, flowNode: Flo
   const name = symbol.name;
   let accessName: Node;
   if (name.startsWith('\ufffe#')) accessName = new PrivateIdentifier(name.substring(name.indexOf('@') + 1));
-  else accessName = new Identifier(name);
+  else accessName = new Identifier(new IdentifierName(name));
   const thisExpression = new KeywordExpression(SyntaxKind.ThisKeyword);
   const reference = new PropertyAccessExpression(thisExpression, undefined, accessName, NodeFlags.None);
   thisExpression.parent = reference;

package/src/compiler/checker-contextual.ts

@@ -7,6 +7,7 @@ import {
   type Node,
   type ParameterDeclaration,
   type PropertyAssignment,
+  getArguments,
   getInitializer,
   getName,
   getParameters,
@@ -224,6 +225,109 @@ export function findContextualNode(c: Checker, node: Node, includeCaches: boolea
   return -1;
 }
 
+/**
+ * The id of the contextual type in force for `node`, or -1 if the node's contextual type is not on
+ * the stack. A key built from -1 can't tell a check under a contextual type that was not pushed from
+ * a check with no contextual type, so callers record nothing under -1.
+ */
+export function getContextualTypeId(c: Checker, node: Node): number {
+  const index = findContextualNode(c, node, true);
+  if (index < 0) return -1;
+  const t = c.inferenceCaches.contextualTypes[index];
+  return t === undefined ? -1 : t.id;
+}
+
+/**
+ * Whether a check of `node` has no contextual type and no inference context, so its type is a
+ * function of the node and the check mode alone: the node is not on the contextual stack, no
+ * inference context contains it, and its parent gives it no contextual type. The parents answered
+ * here are the ones `getContextualTypeEx` returns `undefined` for without computing anything; a
+ * parent it computes a type for is not answered, so the result is never "yes" for a check that
+ * could have a contextual type.
+ *
+ * Types computed inside a flow loop are provisional (the checker does not cache them either), so a
+ * check in a loop is not context-free. The same holds while a reduce label is in force, as when
+ * flow analysis revisits a `finally` block with the antecedents of one outgoing path: the flow
+ * state differs from the one the earlier check of the block saw.
+ */
+export function isCheckedWithoutContextualType(c: Checker, node: Node): boolean {
+  if (c.flowLoopStack.length !== 0) return false;
+  if (c.flowReduceLabels.length !== 0) return false;
+  if (findContextualNode(c, node, true) >= 0) return false;
+  if (getInferenceContext(c, node) !== undefined) return false;
+  const parent = node.parent;
+  if (parent === undefined) return true;
+  switch (parent.kind) {
+    case SyntaxKind.VariableDeclaration:
+    case SyntaxKind.Parameter:
+    case SyntaxKind.PropertyDeclaration:
+    case SyntaxKind.PropertySignature:
+    case SyntaxKind.BindingElement:
+      // Only the initializer is contextually typed by the declaration.
+      return getInitializer(parent) !== node;
+    case SyntaxKind.CallExpression:
+    case SyntaxKind.NewExpression: {
+      // Only the arguments are contextually typed by the parameters; the callee is not.
+      const args = getArguments(parent);
+      if (args !== undefined) {
+        for (const arg of args.nodes) if (arg === node) return false;
+      }
+      return true;
+    }
+    case SyntaxKind.ObjectLiteralExpression:
+      // Only a method takes the property's contextual type.
+      return node.kind !== SyntaxKind.MethodDeclaration;
+    case SyntaxKind.BinaryExpression: {
+      const binary = parent as BinaryExpression;
+      if (binary.type !== undefined) return false;
+      switch (binary.operatorToken.kind) {
+        case SyntaxKind.EqualsToken:
+        case SyntaxKind.AmpersandAmpersandEqualsToken:
+        case SyntaxKind.BarBarEqualsToken:
+        case SyntaxKind.QuestionQuestionEqualsToken:
+          return node !== binary.right;
+        case SyntaxKind.BarBarToken:
+        case SyntaxKind.QuestionQuestionToken:
+        case SyntaxKind.AmpersandAmpersandToken:
+        case SyntaxKind.CommaToken:
+          return false;
+      }
+      return true;
+    }
+    case SyntaxKind.ConditionalExpression: {
+      const conditional = parent as ConditionalExpression;
+      return node !== conditional.whenTrue && node !== conditional.whenFalse;
+    }
+    case SyntaxKind.TemplateSpan: {
+      // Only a tagged template types its spans.
+      const template = parent.parent!;
+      return template.parent === undefined || template.parent.kind !== SyntaxKind.TaggedTemplateExpression;
+    }
+    case SyntaxKind.ArrowFunction:
+    case SyntaxKind.ReturnStatement:
+    case SyntaxKind.YieldExpression:
+    case SyntaxKind.AwaitExpression:
+    case SyntaxKind.Decorator:
+    case SyntaxKind.AsExpression:
+    case SyntaxKind.TypeAssertionExpression:
+    case SyntaxKind.SatisfiesExpression:
+    case SyntaxKind.ExportAssignment:
+    case SyntaxKind.PropertyAssignment:
+    case SyntaxKind.ShorthandPropertyAssignment:
+    case SyntaxKind.SpreadAssignment:
+    case SyntaxKind.ArrayLiteralExpression:
+    case SyntaxKind.ParenthesizedExpression:
+    case SyntaxKind.NonNullExpression:
+    case SyntaxKind.JsxExpression:
+    case SyntaxKind.JsxAttribute:
+    case SyntaxKind.JsxSpreadAttribute:
+    case SyntaxKind.JsxOpeningElement:
+    case SyntaxKind.JsxSelfClosingElement:
+      return false;
+  }
+  return true;
+}
+
 export function pushInferenceContext(c: Checker, node: Node, context: InferenceContext | undefined): void {
   const caches = c.inferenceCaches;
   const depth = caches.inferenceDepth;

package/src/compiler/checker-expressions.ts

@@ -238,7 +238,11 @@ import {
   getNarrowedTypeOfSymbol,
 } from './checker-narrowing.js';
 import { getFlowTypeOfAutoTypedProperty, getThisTypeOfAssignedFunction } from './checker-javascript.js';
-import { checkExpressionWithContextualType, getThisTypeOfObjectLiteralMember } from './checker-contextual.js';
+import {
+  checkExpressionWithContextualType,
+  getThisTypeOfObjectLiteralMember,
+  isCheckedWithoutContextualType,
+} from './checker-contextual.js';
 
 import {
   ContextFlags,
@@ -264,6 +268,16 @@ export function checkExpression(c: Checker, node: Node): Type {
 }
 
 export function checkExpressionEx(c: Checker, node: Node, checkMode: CheckMode): Type {
+  // A completed check of this node under this mode answers this one when the check has no
+  // contextual type and no inference context: the checker's state only grew since, so this check
+  // would produce the type the completed one produced, report the diagnostics it reported and
+  // defer the nodes it deferred. Those diagnostics are equal to ones already reported and a node
+  // is deferred at most once, so serving the completed type changes neither.
+  const recordable = isCheckedWithoutContextualType(c, node);
+  if (recordable) {
+    const recorded = c.exprCheckRecord.get(node.id, checkMode);
+    if (recorded !== undefined) return recorded;
+  }
   const saveCurrentNode = c.currentNode;
   c.currentNode = node;
   c.instantiationCount = 0;
@@ -275,6 +289,7 @@ export function checkExpressionEx(c: Checker, node: Node, checkMode: CheckMode):
   );
   if (isConstEnumObjectTypeLocal(t)) checkConstEnumAccess(c, node, t);
   c.currentNode = saveCurrentNode;
+  if (recordable) c.exprCheckRecord.set(node.id, checkMode, t);
   return t;
 }