tsc-ts 0.1.0 → 0.1.1

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.1",
   "description": "The TypeScript 7 compiler, ported to TypeScript and compiled to a native executable.",
   "license": "Apache-2.0",
   "repository": {
@@ -29,18 +29,18 @@
     "./package.json": "./package.json"
   },
   "dependencies": {
-    "@scriptc/threads": "0.4.7"
+    "@scriptc/threads": "0.4.8"
   },
   "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.1",
+    "@tsc-ts/darwin-x64": "0.1.1",
+    "@tsc-ts/linux-arm64-gnu": "0.1.1",
+    "@tsc-ts/linux-arm64-musl": "0.1.1",
+    "@tsc-ts/linux-x64-gnu": "0.1.1",
+    "@tsc-ts/linux-x64-musl": "0.1.1",
+    "@tsc-ts/win32-x64-msvc": "0.1.1"
   }
 }

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';
@@ -449,11 +450,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 +472,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 +489,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;
@@ -8417,20 +8422,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;
 }
 

package/src/compiler/checker-jsx.ts

@@ -171,6 +171,7 @@ import {
   SymbolFlags,
   type SymbolTable,
 } from './symbol.js';
+import { IdentifierName } from './identifier-name.js';
 
 const enum JsxFlags {
   None = 0,
@@ -1067,7 +1068,7 @@ export function createJsxAttributesTypeFromAttributesProperty(
       // checked as an excess property like the attributes.
       const childrenDeclaration = new PropertySignatureDeclaration(
         undefined,
-        new Identifier(jsxChildrenPropertyName),
+        new Identifier(new IdentifierName(jsxChildrenPropertyName)),
         undefined,
         undefined,
         undefined,

package/src/compiler/checker-type-factory.ts

@@ -1196,40 +1196,79 @@ export function getUnionTypeEx(
 ): Type {
   if (types.length === 0) return c.neverType;
   if (types.length === 1) return types[0]!;
-  // Optimize the common case of unioning a union with some other type, like `undefined`.
-  if (
-    types.length === 2 &&
-    origin === undefined &&
-    ((types[0]!.flags & TypeFlags.Union) !== 0 || (types[1]!.flags & TypeFlags.Union) !== 0)
-  ) {
-    let id1 = types[0]!.id;
-    let id2 = types[1]!.id;
+  // Unioning two types is the common case, both a union with some other type, like `undefined`, and
+  // two constituents of a list, and the same pairs recur. The union is a function of the two types,
+  // the reduction and the alias, so the result is cached by the pair. A union that exceeded the
+  // complexity limit was reported at the expression that needed it and comes back as the error
+  // type: caching that would silence the report at the next expression with the same input list, so
+  // an error result is not cached.
+  if (types.length === 2 && origin === undefined) {
+    const t0 = types[0]!;
+    const t1 = types[1]!;
+    let id1 = t0.id;
+    let id2 = t1.id;
     if (id1 > id2) {
       const t = id1;
       id1 = id2;
       id2 = t;
     }
-    // Without an alias, both ids and the reduction pack into one exact number.
-    if (alias === undefined && id2 < UnionPairIdLimit) {
+    // Without an alias or a constrained intersection, both ids and the reduction pack into one
+    // exact number. A constrained intersection's reduction resolves a type variable's constraint
+    // (`addTypeToUnion`), so those pairs take the general path.
+    if (
+      alias === undefined &&
+      id2 < UnionPairIdLimit &&
+      !isConstrainedIntersection(t0) &&
+      !isConstrainedIntersection(t1)
+    ) {
       const id = (id1 * UnionPairIdLimit + id2) * 4 + unionReduction;
       let result = c.unionOfUnionTypesById.get(id);
       if (result === undefined) {
         result = getUnionTypeWorker(c, types, unionReduction, alias, undefined);
-        c.unionOfUnionTypesById.set(id, result);
+        if (result !== c.errorType) c.unionOfUnionTypesById.set(id, result);
+      }
+      return result;
+    }
+    if ((t0.flags & TypeFlags.Union) !== 0 || (t1.flags & TypeFlags.Union) !== 0) {
+      const key = id1 + ',' + id2 + ',' + unionReduction + aliasKey(alias);
+      let result = c.unionOfUnionTypes.get(key);
+      if (result === undefined) {
+        result = getUnionTypeWorker(c, types, unionReduction, alias, undefined);
+        if (result !== c.errorType) c.unionOfUnionTypes.set(key, result);
       }
       return result;
     }
-    const key = id1 + ',' + id2 + ',' + unionReduction + aliasKey(alias);
-    let result = c.unionOfUnionTypes.get(key);
+  }
+  // Longer lists recur too, from nested unions and from constituents mapped in the same order.
+  // Normalizing a list costs a sort of its constituents and the reductions, and the union is a
+  // function of the list as given, the reduction and the alias, so the result is cached by the list.
+  if (origin === undefined) {
+    const hash = typeListHash(types, alias, unionReduction);
+    let result = c.unionTypesByInputList.get(hash, types, alias, unionReduction);
     if (result === undefined) {
       result = getUnionTypeWorker(c, types, unionReduction, alias, undefined);
-      c.unionOfUnionTypes.set(key, result);
+      if (result !== c.errorType && !hasConstrainedIntersection(types))
+        c.unionTypesByInputList.set(hash, types.slice(), alias, unionReduction, result);
     }
     return result;
   }
   return getUnionTypeWorker(c, types, unionReduction, alias, origin);
 }
 
+/** An intersection that `addTypeToUnion` reduces by resolving a type variable's constraint. */
+function isConstrainedIntersection(t: Type): boolean {
+  return (t.flags & TypeFlags.Intersection) !== 0 && (t.objectFlags & ObjectFlags.IsConstrainedTypeVariable) !== 0;
+}
+
+/** Whether `addTypesToUnion` would set `IncludesConstrainedTypeVariable` for `types`. */
+function hasConstrainedIntersection(types: readonly Type[]): boolean {
+  for (const t of types) {
+    if (isConstrainedIntersection(t)) return true;
+    if ((t.flags & TypeFlags.Union) !== 0 && hasConstrainedIntersection((t as UnionType).types)) return true;
+  }
+  return false;
+}
+
 class TypeSet {
   types: Type[] = [];
   includes = 0;

package/src/compiler/checker.ts

@@ -41,6 +41,7 @@ import {
   PagedIdSet,
   SparseLinkTable,
 } from './link-tables.js';
+import { ExprCheckRecord } from './expr-record.js';
 import { getErrorRangeForNode, getSourceFileOfNode } from './binder-utilities.js';
 import {
   Diagnostic,
@@ -138,7 +139,7 @@ import type { GrammarChecker } from './checker-grammar.js';
 import type { ResolvedModule } from './module-resolution-types.js';
 import type { ModuleSpecifierHost } from './module-specifiers.js';
 import type { PropertyListIndex } from './checker-members.js';
-import { shareThreads, startThreadSharing, type ThreadSharing } from './shared-results.js';
+import { startThreadSharing, type ThreadSharing } from './shared-results.js';
 
 /** What the checker needs from a program. */
 export abstract class CheckerHost {
@@ -489,6 +490,8 @@ export class Checker implements TypeChecking {
   readonly resolvedSymbols = new CompactLinkTable<Symbol>();
   /** The resolved type of a type node or expression. */
   readonly resolvedTypes = new CompactLinkTable<Type>();
+  /** The type the last completed check of each expression key produced (expr-record.ts). */
+  readonly exprCheckRecord = new ExprCheckRecord();
   /** The resolved signature of a call-like node or a signature declaration. */
   readonly resolvedSignatures = new CompactLinkTable<Signature>();
   /** Merged symbols, indexed by the id of the symbol merged into them. */
@@ -542,6 +545,7 @@ export class Checker implements TypeChecking {
   readonly unionOfUnionTypes = new Map<string, Type>();
   /** `unionOfUnionTypes` without an alias, by both ids and the reduction packed into one number. */
   readonly unionOfUnionTypesById = new Map<number, Type>();
+  readonly unionTypesByInputList = new TypeListCache<Type>();
   readonly intersectionTypes = new TypeListCache<Type>();
   readonly tupleTypes = new Map<string, Type>();
   readonly indexedAccessTypes = new Map<string, Type>();
@@ -717,7 +721,7 @@ export class Checker implements TypeChecking {
   deferDiagnostic(node: Node, report: () => void): void {
     this.deferredDiagnostics.push(report);
     if (this.deferredDiagnosticFiles !== undefined)
-      this.deferredDiagnosticFiles.push(getSourceFileOfNode(node).fileName);
+      this.deferredDiagnosticFiles.push(this.fileIndex.get(getSourceFileOfNode(node)) ?? -1);
   }
 
   /**
@@ -843,7 +847,7 @@ export class Checker implements TypeChecking {
   /** The access flags of the key `getIndexedAccessTypeEx` keeps each indexed access type by. */
   indexedAccessKeyFlags: Map<Type, number> | undefined = undefined;
   /** Where results are shared between checker threads (shared-results.ts): the file of each diagnostic deferred. */
-  deferredDiagnosticFiles: string[] | undefined = undefined;
+  deferredDiagnosticFiles: number[] | undefined = undefined;
 
   constructor(host: CheckerHost) {
     this.host = host;
@@ -1056,7 +1060,9 @@ export class Checker implements TypeChecking {
     mergeAmbientModulesAndAugmentations(this);
     this.modulesMerged = true;
     this.mergeDiagnostics.push(this.diagnostics.takeLog(), this.suggestionDiagnostics.takeLog());
-    if (shareThreads) startThreadSharing(this);
+    // Returns unless this thread was given sharing data (`ThreadSharingData` in its worker data): the
+    // main thread, and every thread of a run that didn't share.
+    startThreadSharing(this);
     if (this.threadSharing !== undefined) {
       this.distributedConditionals = new Map<Type, DistributedConditional>();
       this.distributedByKey = new Map<string, Type>();
@@ -1271,6 +1277,7 @@ export function disposeChecker(c: Checker): void {
   c.unionTypes.clear();
   c.unionOfUnionTypes.clear();
   c.unionOfUnionTypesById.clear();
+  c.unionTypesByInputList.clear();
   c.intersectionTypes.clear();
   c.tupleTypes.clear();
   c.indexedAccessTypes.clear();

package/src/compiler/compile-program.ts

@@ -375,6 +375,12 @@ export abstract class CompilerProgram {
     this.emitter = new ProgramEmitter(checked);
   }
 
+  /**
+   * Whether this run checked the program, which `getDiagnosticsOfProgram` sets when it checks it. A run
+   * stopped before checking, by syntax errors or `--noCheck`, keeps no record (`run-records.ts`).
+   */
+  checkedTheProgram = false;
+
   /**
    * The time spent in declaration emit while checking, to count as emit time rather than check time, since
    * the last call. Only an incremental program emits while checking, to compute signatures.
@@ -530,6 +536,8 @@ export function getDiagnosticsOfProgram(
   // Those found by checking come after the semantic diagnostics, as with a single checker.
   for (const d of program.getGlobalDiagnostics(false)) result.push(d);
   if (result.length === configCount) {
+    // With `--noCheck` the checker skips every file: the run checked nothing to sample (`run-records.ts`).
+    if (options.noCheck !== true) program.checkedTheProgram = true;
     const checkStart = performance.now();
     const semantic = program.getSemanticDiagnostics();
     // Declaration emit that computed signatures while checking counts as emit time, as in TypeScript 7.1.