tsc-ts 0.1.0 → 0.1.1

package/README.md

@@ -33,7 +33,7 @@ npx tsc-ts --noEmit src/index.ts
 
 `tsc-ts --api` serves the TypeScript API over stdin and stdout, like `tsc --api`. On Windows, `--api --pipe \\.\pipe\<name>` serves it over a named pipe it creates, as `tsc --api --pipe` does, for clients that connect to the pipe (such as scriptc under Node.js); only the native executable supports `--pipe`. On macOS and Linux, `--api --listen <path>` serves it on a Unix socket it creates, with mode 0600, to one client of the same user at a time, each until the client closes its end. Each client gets the answers a new `tsc-ts --api` process would give, except that symbol ids continue from earlier clients, and the server reads every file through the client again, but it keeps parsed files between clients and reuses those whose text is unchanged, along with the encoding `getSourceFile` sends for each, so a client that opens the same project again loads it faster. The server exits when no client connects for 60 seconds (`--idle-exit <seconds>` sets the time), or after a client when its resident memory is above 2.5 times what it held after its first client (`TSC_TS_LISTEN_MEMORY` sets the limit in megabytes). To stop, it removes the socket file, serves the clients that had connected, and exits. It replaces a socket file that no server answers on, such as one left by a server that was killed. Only the native executable supports `--listen`. With `--default-libraries-from-disk`, the server reads the files in its default library directory (`TSC_TS_LIB_DIR`, or the executable's directory) from the disk itself, even when the client handles file system calls (`--callbacks`), which saves a round trip to the client for each library file.
 
-`--checkers N` checks the program on N threads. Unless `--checkers` or `--singleThreaded` is given, the native executable uses one checker per CPU it may run on (up to 16), and at least tsgo's four; it uses fewer than the CPUs, but never fewer than four, when the estimated peak memory of more checkers would not fit 85% of the machine's memory (`TSC_TS_CHECKERS=fixed` keeps tsgo's four), and checkers beyond the fourth stop taking files, one at a time, when the process's memory reaches that share; it shares one program between its threads and also parses and binds the program's files on them. Unless `--singleThreaded` is given, the program's files are parsed and bound on threads also with `--checkers 1` and in the first build of `--watch`, with or without build info, as tsgo does. Files that share costly declarations, such as a large generated schema and the few files importing it, are checked together on one checker. Under Node.js, where every thread builds its own copy of the program, tsc-ts checks on one thread unless `--checkers` is given. `--incremental`, `--watch` and `--build` always check on one thread. The diagnostics are the same as with one checker.
+`--checkers N` checks the program on N threads. Unless `--checkers` or `--singleThreaded` is given, the native executable uses one checker per CPU it may run on (up to 16), and at least tsgo's four; it uses fewer than the CPUs, but never fewer than four, when the estimated peak memory of more checkers would not fit 85% of the machine's memory (`TSC_TS_CHECKERS=fixed` keeps tsgo's four), and checkers beyond the fourth stop taking files, one at a time, when the process's memory reaches that share; it shares one program between its threads and also parses and binds the program's files on them. Unless `--singleThreaded` is given, the program's files are parsed and bound on threads also with `--checkers 1` and in the first build of `--watch`, with or without build info, as tsgo does. Files that share costly declarations, such as a large generated schema and the few files importing it, are checked together on one checker. The checker threads share the results they compute where the run expects that to pay: at 12 or more checkers, when 40% of the program's files are declarations or come from `node_modules` and the checkers' ranges mostly resolve the same large libraries. `TSC_TS_SHARE=1` turns sharing on for any program and `TSC_TS_SHARE=0` keeps it off, and a run whose sharing stops paying stops sharing its results as it goes. A sharing run may also bound how many results it posts at a time, which costs a few percent on a project that does not gain by it and saves more on one that does: the learned choice among a project's runs, off until its record shows it faster, and `TSC_TS_SHARE_BOUNDED=1` turns it on for any program while `TSC_TS_SHARE_BOUNDED=0` keeps it off. `TSC_TS_AUTO=0` keeps the choices of a run before automatic selection (fewer checkers where the ranges resolve large libraries, no sharing), and `TSC_TS_AUTO=static` keeps the rules and the in-run switches but reads and writes no records, and `TSC_TS_AUTO=explore` adds the experimental exploration described below. Unless `--singleThreaded` is given, the files are parsed on the CPUs the process may run on, but one, whatever the checker count, and `TSC_TS_PARSE_THREADS` sets how many. `--extendedDiagnostics` prints the checker threads, the sharing and the parse threads after the statistics table, under `Suggestions:`, with where each value came from (`pinned: --checkers`, `default`, `automatic: ...`, `learned: check 14% faster over 3 runs`, `exploring`, `control`) and how to pin it; `--build` prints one section per project it builds. The section also names the run's record under `Records:`. Each run that checks a program writes what it measured to `~/.cache/tsc-ts/runs-v1/` (`TSC_TS_CACHE_DIR` sets the directory, `TSC_TS_CACHE=0` turns records off), for later runs of the same project on the same machine to read. A later run chooses from that record where the rules left a setting open: a configuration the samples show faster than the static choice — by 3% or twice the standard error of the gains each of its samples makes against the nearest run of the other arm, on three samples of each taken while the machine was not busy — is adopted, every sixteenth run (and the first after two weeks) re-measures the static choice as a control run, and an adopted configuration whose last three samples all fall behind the control runs reverts at once. A run never tries a configuration that could make itself slower: it adopts only what the samples already show faster, from `tsc-ts doctor`, from a pinned run or from a run that already used it. `TSC_TS_AUTO=explore` turns on an experimental alternative in which a run also tries a setting the signals leave uncertain: one run in eight tries three quarters of the count where the library text puts it near the cut, sharing at eight checkers near the rule's limits, or half the parse threads, and such a run is slower than the configuration it would have used. A program whose shape changed by more than 15% discards the record's samples. Watch mode, a `--build` of several projects at once, `--singleThreaded`, Node builds and `TSC_TS_AUTO=0` or `static` keep no record, and the section says why; a run with `CI` set reads and adopts but never explores. `tsc-ts doctor [-p <tsconfig>] [--runs N] [--budget SECONDS] [--emit] [--json] [--no-save]` measures these settings on this machine: it runs the project's check under the default configuration, with sharing on, with up to 16 checkers, with both, and with half the parse threads, compares the phase times by the same rule automatic selection uses, and prints what it recommends with the evidence for it. Each measured run is a child process, so it runs as a user's run would, and it writes what it measured to the file named by `TSC_TS_DOCTOR_REPORT`; runs without the variable are unaffected. Doctor stores its samples in the record with role `doctor`, unless `--no-save` is given. The command is experimental: the configurations it compares and what it recommends may change. Under Node.js, where every thread builds its own copy of the program, tsc-ts checks on one thread unless `--checkers` is given. `--incremental`, `--watch` and `--build` always check on one thread. The diagnostics are the same as with one checker.
 
 The native executable never frees syntax trees, types, signatures or symbols: it keeps them until it exits, which saves the cost of tracking them during a build. A one-shot build is unaffected, but a long-running process grows with each rebuild or project update. Native `--watch` (also with `--build`) runs in a child process, and when a change arrives while that process holds more than 2.5 times the memory it held after its first build, a new process replaces it and builds the change, reporting what the old process would have. `TSC_TS_WATCH_MEMORY` sets that limit in megabytes, and `TSC_TS_WATCH_MEMORY=0` turns the replacement off. A `--api` process grows with each project update; restart it to reclaim the memory.
 

package/dist/api/compiler/ast.d.ts

@@ -1,4 +1,5 @@
 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';
@@ -242,8 +243,9 @@ export declare class Token extends Node {
     copy(): Token;
 }
 export declare class Identifier extends Node {
-    text: string;
-    constructor(text: string);
+    readonly identifierName: IdentifierName;
+    constructor(name: IdentifierName);
+    get text(): string;
     forEachChild(_v: NodeVisitor): boolean;
     setParentOfChildren(): void;
     deepClone(): Node;
@@ -256,7 +258,7 @@ export declare class Identifier extends Node {
  */
 export declare class ReferenceIdentifier extends Identifier {
     flowNode: FlowNode | undefined;
-    constructor(text: string);
+    constructor(name: IdentifierName);
     copy(): Identifier;
 }
 export declare class PrivateIdentifier extends Node {
@@ -2346,6 +2348,10 @@ export declare 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);
     matches(candidate: string): boolean;
 }

package/dist/api/compiler/ast.js

@@ -221,10 +221,13 @@ export class Token extends Node {
     }
 }
 export class Identifier extends Node {
-    text;
-    constructor(text) {
+    identifierName;
+    constructor(name) {
         super(79 /* SyntaxKind.Identifier */);
-        this.text = text;
+        this.identifierName = name;
+    }
+    get text() {
+        return this.identifierName.text;
     }
     forEachChild(_v) {
         return false;
@@ -234,7 +237,7 @@ export class Identifier extends Node {
         return this.copy();
     }
     copy() {
-        const node = new Identifier(this.text);
+        const node = new Identifier(this.identifierName);
         node.flags = this.flags;
         node.pos = this.pos;
         node.end = this.end;
@@ -249,12 +252,12 @@ export class Identifier extends Node {
 export class ReferenceIdentifier extends Identifier {
     // Set by the binder.
     flowNode;
-    constructor(text) {
-        super(text);
+    constructor(name) {
+        super(name);
         this.flowNode = undefined;
     }
     copy() {
-        const node = new ReferenceIdentifier(this.text);
+        const node = new ReferenceIdentifier(this.identifierName);
         node.flags = this.flags;
         node.pos = this.pos;
         node.end = this.end;
@@ -6782,17 +6785,19 @@ export class PatternAmbientModule {
     text;
     starIndex;
     symbol;
+    /** The part of `text` before `starIndex`, kept so a match does not copy it. */
+    prefix;
+    /** The part of `text` after `starIndex`, kept so a match does not copy it. */
+    suffix;
     constructor(text, starIndex, symbol) {
         this.text = text;
         this.starIndex = starIndex;
         this.symbol = symbol;
+        this.prefix = text.substring(0, starIndex);
+        this.suffix = text.substring(starIndex + 1);
     }
     matches(candidate) {
-        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)));
+        return (candidate.length >= this.text.length - 1 && candidate.startsWith(this.prefix) && candidate.endsWith(this.suffix));
     }
 }
 function containsNonASCII(text) {

package/dist/api/compiler/checker-classes.js

@@ -28,6 +28,7 @@ import { checkFunctionOrConstructorSymbol, checkFunctionOrMethodSymbols } from '
 import { checkClassHeritage, checkClassOrInterfaceForDuplicateIndexSignatures, checkInterfaceHeritage, } 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, node) {
     checkClassLikeDeclaration(c, node);
     checkClassMembers(c, node);
@@ -464,7 +465,7 @@ function newThisPropertyReference(symbol, container, flowNode) {
     if (name.startsWith('\ufffe#'))
         accessName = new PrivateIdentifier(name.substring(name.indexOf('@') + 1));
     else
-        accessName = new Identifier(name);
+        accessName = new Identifier(new IdentifierName(name));
     const thisExpression = new KeywordExpression(109 /* SyntaxKind.ThisKeyword */);
     const reference = new PropertyAccessExpression(thisExpression, undefined, accessName, 0 /* NodeFlags.None */);
     thisExpression.parent = reference;

package/dist/api/compiler/checker-contextual.d.ts

@@ -18,6 +18,26 @@ export declare function pushCachedContextualType(c: Checker, node: Node): void;
 export declare function popContextualType(c: Checker): void;
 /** The index of the contextual type pushed onto `node`, or -1. */
 export declare function findContextualNode(c: Checker, node: Node, includeCaches: boolean): number;
+/**
+ * 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 declare function getContextualTypeId(c: Checker, node: Node): number;
+/**
+ * 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 declare function isCheckedWithoutContextualType(c: Checker, node: Node): boolean;
 export declare function pushInferenceContext(c: Checker, node: Node, context: InferenceContext | undefined): void;
 export declare function popInferenceContext(c: Checker): void;
 /** The inference context of the innermost call argument containing `node`. */

package/dist/api/compiler/checker-contextual.js

@@ -1,6 +1,6 @@
 // Contextual typing: the type an expression's position implies, and contextual signatures.
 import { resolvedReturnTypeOf } from './side-state.js';
-import { getInitializer, getName, getParameters, getType, getText, getSymbol, getTypeParameters, JsxAttribute, JsxElement, } from './ast.js';
+import { getArguments, getInitializer, getName, getParameters, getType, getText, getSymbol, getTypeParameters, JsxAttribute, JsxElement, } from './ast.js';
 import { getImmediatelyInvokedFunctionExpression, isFunctionExpressionOrArrowFunction, isObjectLiteralMethod, isStatic, } from './binder-utilities.js';
 import { filterType, getIntersectionType, getNumberLiteralType, getRegularTypeOfLiteralType, getUnionType, getUnionTypeEx, getWidenedLiteralType, getEndElementCount, getStringLiteralType, getTypeArguments, getTypeReferenceArity, mapType, mapTypeEx, isTupleType, tupleTargetOf, typesOf, } from './checker-type-factory.js';
 import { combineUnionOrIntersectionMemberSignatures, compareTypeParametersIdentical, findApplicableIndexInfo, getApparentType, getBaseConstraintOrType, getIndexInfosOfStructuredType, getPropertiesOfType, getPropertyOfType, getReducedType, getSignaturesOfType, } from './checker-members.js';
@@ -68,6 +68,116 @@ export function findContextualNode(c, node, includeCaches) {
             return i;
     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, node) {
+    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, node) {
+    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 262 /* SyntaxKind.VariableDeclaration */:
+        case 171 /* SyntaxKind.Parameter */:
+        case 174 /* SyntaxKind.PropertyDeclaration */:
+        case 173 /* SyntaxKind.PropertySignature */:
+        case 210 /* SyntaxKind.BindingElement */:
+            // Only the initializer is contextually typed by the declaration.
+            return getInitializer(parent) !== node;
+        case 215 /* SyntaxKind.CallExpression */:
+        case 216 /* 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 212 /* SyntaxKind.ObjectLiteralExpression */:
+            // Only a method takes the property's contextual type.
+            return node.kind !== 176 /* SyntaxKind.MethodDeclaration */;
+        case 228 /* SyntaxKind.BinaryExpression */: {
+            const binary = parent;
+            if (binary.type !== undefined)
+                return false;
+            switch (binary.operatorToken.kind) {
+                case 63 /* SyntaxKind.EqualsToken */:
+                case 76 /* SyntaxKind.AmpersandAmpersandEqualsToken */:
+                case 75 /* SyntaxKind.BarBarEqualsToken */:
+                case 77 /* SyntaxKind.QuestionQuestionEqualsToken */:
+                    return node !== binary.right;
+                case 56 /* SyntaxKind.BarBarToken */:
+                case 60 /* SyntaxKind.QuestionQuestionToken */:
+                case 55 /* SyntaxKind.AmpersandAmpersandToken */:
+                case 27 /* SyntaxKind.CommaToken */:
+                    return false;
+            }
+            return true;
+        }
+        case 229 /* SyntaxKind.ConditionalExpression */: {
+            const conditional = parent;
+            return node !== conditional.whenTrue && node !== conditional.whenFalse;
+        }
+        case 241 /* SyntaxKind.TemplateSpan */: {
+            // Only a tagged template types its spans.
+            const template = parent.parent;
+            return template.parent === undefined || template.parent.kind !== 217 /* SyntaxKind.TaggedTemplateExpression */;
+        }
+        case 221 /* SyntaxKind.ArrowFunction */:
+        case 255 /* SyntaxKind.ReturnStatement */:
+        case 231 /* SyntaxKind.YieldExpression */:
+        case 225 /* SyntaxKind.AwaitExpression */:
+        case 172 /* SyntaxKind.Decorator */:
+        case 236 /* SyntaxKind.AsExpression */:
+        case 218 /* SyntaxKind.TypeAssertionExpression */:
+        case 240 /* SyntaxKind.SatisfiesExpression */:
+        case 279 /* SyntaxKind.ExportAssignment */:
+        case 304 /* SyntaxKind.PropertyAssignment */:
+        case 305 /* SyntaxKind.ShorthandPropertyAssignment */:
+        case 306 /* SyntaxKind.SpreadAssignment */:
+        case 211 /* SyntaxKind.ArrayLiteralExpression */:
+        case 219 /* SyntaxKind.ParenthesizedExpression */:
+        case 237 /* SyntaxKind.NonNullExpression */:
+        case 296 /* SyntaxKind.JsxExpression */:
+        case 293 /* SyntaxKind.JsxAttribute */:
+        case 295 /* SyntaxKind.JsxSpreadAttribute */:
+        case 288 /* SyntaxKind.JsxOpeningElement */:
+        case 287 /* SyntaxKind.JsxSelfClosingElement */:
+            return false;
+    }
+    return true;
+}
 export function pushInferenceContext(c, node, context) {
     const caches = c.inferenceCaches;
     const depth = caches.inferenceDepth;

package/dist/api/compiler/checker-expressions.js

@@ -43,7 +43,7 @@ import { isFunctionLike, isImportCall, isInJSFile, isRequireCall } from './ast-u
 import { isLiteralKind } from './printer/utilities.js';
 import { convertAutoToAny, isEvolvingArrayOperationTarget, getAssignmentTargetKind, getControlFlowContainer, isConstantVariable, isInCompoundLikeAssignment, isMutableLocalVariableDeclaration, isParameterOrMutableLocalVariable, isPastLastAssignment, isSymbolAssignedDefinitely, getFlowTypeOfReference, 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 { getInferenceContext, instantiateContextualType, popContextualType, pushCachedContextualType, } from './checker-contextual.js';
 import { addIntraExpressionInferenceSite, isConstTypeVariable } from './checker-inference.js';
 import { isContextSensitiveFunctionOrObjectLiteralMethod } from './checker-contextual.js';
@@ -56,6 +56,17 @@ export function checkExpression(c, node) {
     return checkExpressionEx(c, node, 0 /* CheckMode.Normal */);
 }
 export function checkExpressionEx(c, node, checkMode) {
+    // 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;
@@ -63,6 +74,8 @@ export function checkExpressionEx(c, node, checkMode) {
     if (isConstEnumObjectTypeLocal(t))
         checkConstEnumAccess(c, node, t);
     c.currentNode = saveCurrentNode;
+    if (recordable)
+        c.exprCheckRecord.set(node.id, checkMode, t);
     return t;
 }
 /**

package/dist/api/compiler/checker-jsx.js

@@ -38,6 +38,7 @@ import { filterType, isTupleType } from './checker-type-factory.js';
 import { createTypeFromGenericGlobalType } from './checker-type-factory.js';
 import { isTypeAssignableTo } from './relations.js';
 import { copyDeclarations, declarationCount, getSymbolId, } from './symbol.js';
+import { IdentifierName } from './identifier-name.js';
 // Names in the `JSX` namespace.
 const jsxNamespaceName = 'JSX';
 const jsxIntrinsicElementsName = 'IntrinsicElements';
@@ -824,7 +825,7 @@ export function createJsxAttributesTypeFromAttributesProperty(c, openingLikeElem
                 c.symbolTypes.set(id, createArrayType(c, getUnionType(c, childTypes)));
             // A property signature in the attributes declares the synthetic `children` property, so it is
             // checked as an excess property like the attributes.
-            const childrenDeclaration = new PropertySignatureDeclaration(undefined, new Identifier(jsxChildrenPropertyName), undefined, undefined, undefined);
+            const childrenDeclaration = new PropertySignatureDeclaration(undefined, new Identifier(new IdentifierName(jsxChildrenPropertyName)), undefined, undefined, undefined);
             childrenDeclaration.parent = attributeParent;
             childrenDeclaration.symbol = childrenPropSymbol;
             childrenPropSymbol.valueDeclaration = childrenDeclaration;

package/dist/api/compiler/checker-type-factory.js

@@ -1187,37 +1187,78 @@ export function getUnionTypeEx(c, types, unionReduction, alias, origin) {
         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 & 134217728 /* TypeFlags.Union */) !== 0 || (types[1].flags & 134217728 /* 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;
         }
-        const key = id1 + ',' + id2 + ',' + unionReduction + aliasKey(alias);
-        let result = c.unionOfUnionTypes.get(key);
+        if ((t0.flags & 134217728 /* TypeFlags.Union */) !== 0 || (t1.flags & 134217728 /* 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;
+        }
+    }
+    // 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) {
+    return (t.flags & 268435456 /* TypeFlags.Intersection */) !== 0 && (t.objectFlags & 134217728 /* ObjectFlags.IsConstrainedTypeVariable */) !== 0;
+}
+/** Whether `addTypesToUnion` would set `IncludesConstrainedTypeVariable` for `types`. */
+function hasConstrainedIntersection(types) {
+    for (const t of types) {
+        if (isConstrainedIntersection(t))
+            return true;
+        if ((t.flags & 134217728 /* TypeFlags.Union */) !== 0 && hasConstrainedIntersection(t.types))
+            return true;
+    }
+    return false;
+}
 class TypeSet {
     types = [];
     includes = 0;

package/dist/api/compiler/checker.d.ts

@@ -2,6 +2,7 @@ import type { ModuleSpecifierResult } from './node-builder-names.js';
 import type { EmitHelperFileLinks } from './checker-emit-helpers.js';
 import type { Node, PatternAmbientModule, SourceFile } from './ast.js';
 import { CompactIntLinkTable, CompactLinkTable, IntLinkTable, LinkTable, PagedIdSet, SparseLinkTable } from './link-tables.js';
+import { ExprCheckRecord } from './expr-record.js';
 import { Diagnostic, type DiagnosticMessage, Diagnostics } from './diagnostics.js';
 import { type CompilerOptions, ModuleKind, ScriptTarget } from './options.js';
 import { CheckFlags, Symbol, SymbolFlags, type SymbolTable } from './symbol.js';
@@ -225,6 +226,8 @@ export declare class Checker implements TypeChecking {
     readonly resolvedSymbols: CompactLinkTable<Symbol>;
     /** The resolved type of a type node or expression. */
     readonly resolvedTypes: CompactLinkTable<Type>;
+    /** The type the last completed check of each expression key produced (expr-record.ts). */
+    readonly exprCheckRecord: ExprCheckRecord;
     /** The resolved signature of a call-like node or a signature declaration. */
     readonly resolvedSignatures: CompactLinkTable<Signature>;
     /** Merged symbols, indexed by the id of the symbol merged into them. */
@@ -274,6 +277,7 @@ export declare class Checker implements TypeChecking {
     readonly unionOfUnionTypes: Map<string, Type>;
     /** `unionOfUnionTypes` without an alias, by both ids and the reduction packed into one number. */
     readonly unionOfUnionTypesById: Map<number, Type>;
+    readonly unionTypesByInputList: TypeListCache<Type>;
     readonly intersectionTypes: TypeListCache<Type>;
     readonly tupleTypes: Map<string, Type>;
     readonly indexedAccessTypes: Map<string, Type>;
@@ -548,7 +552,7 @@ export declare class Checker implements TypeChecking {
     /** The access flags of the key `getIndexedAccessTypeEx` keeps each indexed access type by. */
     indexedAccessKeyFlags: Map<Type, number> | undefined;
     /** Where results are shared between checker threads (shared-results.ts): the file of each diagnostic deferred. */
-    deferredDiagnosticFiles: string[] | undefined;
+    deferredDiagnosticFiles: number[] | undefined;
     constructor(host: CheckerHost);
     /** Checks `file` if needed and returns its semantic diagnostics, sorted. */
     getDiagnostics(file: SourceFile): Diagnostic[];

package/dist/api/compiler/checker.js

@@ -1,5 +1,6 @@
 import { sideOf } from './side-state.js';
 import { CompactIntLinkTable, CompactLinkTable, IntLinkTable, LinkTable, PagedIdSet, SparseLinkTable, } from './link-tables.js';
+import { ExprCheckRecord } from './expr-record.js';
 import { getErrorRangeForNode, getSourceFileOfNode } from './binder-utilities.js';
 import { Diagnostic, compareDiagnostics, equalDiagnostics, } from './diagnostics.js';
 import { ModuleKind, ScriptTarget, getEmitScriptTarget, getIsolatedModules, getStrictOptionValue, shouldPreserveConstEnums, } from './options.js';
@@ -17,7 +18,7 @@ import { InferenceCaches } from './checker-inference.js';
 import { AssignmentMarker } from './checker-narrowing.js';
 import { JsxState } from './checker-jsx.js';
 import { SourceFileMetadata, getEmitModuleFormatOfFile } from './program-utilities.js';
-import { shareThreads, startThreadSharing } from './shared-results.js';
+import { startThreadSharing } from './shared-results.js';
 /** What the checker needs from a program. */
 export class CheckerHost {
     /** How a module name in `file` resolved in `mode`, if the program resolved it. */
@@ -358,6 +359,8 @@ export class Checker {
     resolvedSymbols = new CompactLinkTable();
     /** The resolved type of a type node or expression. */
     resolvedTypes = new CompactLinkTable();
+    /** The type the last completed check of each expression key produced (expr-record.ts). */
+    exprCheckRecord = new ExprCheckRecord();
     /** The resolved signature of a call-like node or a signature declaration. */
     resolvedSignatures = new CompactLinkTable();
     /** Merged symbols, indexed by the id of the symbol merged into them. */
@@ -409,6 +412,7 @@ export class Checker {
     unionOfUnionTypes = new Map();
     /** `unionOfUnionTypes` without an alias, by both ids and the reduction packed into one number. */
     unionOfUnionTypesById = new Map();
+    unionTypesByInputList = new TypeListCache();
     intersectionTypes = new TypeListCache();
     tupleTypes = new Map();
     indexedAccessTypes = new Map();
@@ -576,7 +580,7 @@ export class Checker {
     deferDiagnostic(node, report) {
         this.deferredDiagnostics.push(report);
         if (this.deferredDiagnosticFiles !== undefined)
-            this.deferredDiagnosticFiles.push(getSourceFileOfNode(node).fileName);
+            this.deferredDiagnosticFiles.push(this.fileIndex.get(getSourceFileOfNode(node)) ?? -1);
     }
     /**
      * The checked object literals of each file whose members may set deprecated properties of their contextual
@@ -886,8 +890,9 @@ export class Checker {
         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();
             this.distributedByKey = new Map();
@@ -1059,6 +1064,7 @@ export function disposeChecker(c) {
     c.unionTypes.clear();
     c.unionOfUnionTypes.clear();
     c.unionOfUnionTypesById.clear();
+    c.unionTypesByInputList.clear();
     c.intersectionTypes.clear();
     c.tupleTypes.clear();
     c.indexedAccessTypes.clear();

package/dist/api/compiler/compile-program.d.ts

@@ -105,6 +105,11 @@ export declare abstract class CompilerProgram {
     readonly times: CompileTimes;
     readonly emitter: ProgramEmitter;
     constructor(checked: CheckedProgram, times: CompileTimes);
+    /**
+     * 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: boolean;
     /**
      * 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.

package/dist/api/compiler/compile-program.js

@@ -311,6 +311,11 @@ export class CompilerProgram {
         this.times = times;
         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.
@@ -447,6 +452,9 @@ export function getDiagnosticsOfProgram(program, withDeclarationDiagnostics, dec
     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.

package/dist/api/compiler/expr-record.d.ts

@@ -0,0 +1,11 @@
+import type { Type } from './checker-types.js';
+export declare class ExprCheckRecord {
+    /** The node id of the check at each entry, plus one; zero where no check is recorded. */
+    private readonly nodeIds;
+    private readonly modes;
+    private readonly types;
+    /** The type the last completed check of the node under `mode` produced, if the entry holds it. */
+    get(nodeId: number, mode: number): Type | undefined;
+    /** Records that a check of the node under `mode` produced `type`. */
+    set(nodeId: number, mode: number, type: Type): void;
+}