tsc-ts 0.1.0 → 0.1.2

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

@@ -668,17 +668,18 @@ function areTypeParametersIdentical(c, lists, targetParameters) {
  * (with `checkPrivateNames`) private names shared by static and instance members.
  */
 export function checkObjectTypeForDuplicateDeclarations(c, node, checkPrivateNames) {
-    const instanceNames = new Map();
-    const staticNames = new Map();
-    const privateNames = new Map();
+    // Only a symbol with several declarations can be a duplicate, so the maps are created for the first one.
+    let instanceNames;
+    let staticNames;
+    let privateNames;
     const nodeInAmbientContext = (node.flags & 8388608 /* NodeFlags.Ambient */) !== 0;
     for (const member of getMembers(node).nodes) {
         if (member.kind === 178 /* SyntaxKind.Constructor */) {
             for (const param of getParameters(member).nodes)
                 if (isParameterPropertyDeclaration(param, member) && !isBindingPattern(getName(param))) {
                     const symbol = getSymbolOfDeclaration(c, param);
-                    if (symbol !== undefined)
-                        checkPropertyOrAccessor(c, node, instanceNames, symbol, 1 /* MemberKind.Property */, false);
+                    if (symbol !== undefined && declarationCount(symbol) > 1)
+                        checkPropertyOrAccessor(c, node, (instanceNames ??= new Map()), symbol, 1 /* MemberKind.Property */, false);
                 }
             continue;
         }
@@ -688,17 +689,22 @@ export function checkObjectTypeForDuplicateDeclarations(c, node, checkPrivateNam
         const memberIsStatic = hasStaticModifier(member);
         if (!nodeInAmbientContext && memberIsStatic && symbol.name === 'prototype')
             c.error(getName(member), 838 /* Diagnostics.Static_property_0_conflicts_with_built_in_property_Function_0_of_constructor_function_1 */, symbol.name, symbolToString(c, getSymbolOfDeclaration(c, node)));
-        const names = memberIsStatic ? staticNames : instanceNames;
-        const hasAccessorModifier = hasSyntacticModifier(member, 512 /* ModifierFlags.Accessor */);
-        if ((member.kind === 174 /* SyntaxKind.PropertyDeclaration */ && !hasAccessorModifier) ||
-            member.kind === 173 /* SyntaxKind.PropertySignature */)
-            checkPropertyOrAccessor(c, node, names, symbol, 1 /* MemberKind.Property */, memberIsStatic);
-        else if (member.kind === 179 /* SyntaxKind.GetAccessor */ ||
-            member.kind === 180 /* SyntaxKind.SetAccessor */ ||
-            (member.kind === 174 /* SyntaxKind.PropertyDeclaration */ && hasAccessorModifier))
-            checkPropertyOrAccessor(c, node, names, symbol, 2 /* MemberKind.Accessor */, memberIsStatic);
+        if (declarationCount(symbol) > 1) {
+            const names = memberIsStatic
+                ? (staticNames ??= new Map())
+                : (instanceNames ??= new Map());
+            const hasAccessorModifier = hasSyntacticModifier(member, 512 /* ModifierFlags.Accessor */);
+            if ((member.kind === 174 /* SyntaxKind.PropertyDeclaration */ && !hasAccessorModifier) ||
+                member.kind === 173 /* SyntaxKind.PropertySignature */)
+                checkPropertyOrAccessor(c, node, names, symbol, 1 /* MemberKind.Property */, memberIsStatic);
+            else if (member.kind === 179 /* SyntaxKind.GetAccessor */ ||
+                member.kind === 180 /* SyntaxKind.SetAccessor */ ||
+                (member.kind === 174 /* SyntaxKind.PropertyDeclaration */ && hasAccessorModifier))
+                checkPropertyOrAccessor(c, node, names, symbol, 2 /* MemberKind.Accessor */, memberIsStatic);
+        }
         const name = getName(member);
         if (checkPrivateNames && name !== undefined && name.kind === 80 /* SyntaxKind.PrivateIdentifier */) {
+            privateNames ??= new Map();
             let flags = privateNames.get(symbol.name) ?? 0;
             if (flags === 3)
                 continue;

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-modules.js

@@ -1525,7 +1525,8 @@ function getSymbolFlagsExcludingTypeOnly(c, symbol) {
 }
 /** `getSymbolFlags`, optionally stopping at type-only aliases or leaving out the symbol's own flags. */
 function getSymbolFlagsEx(c, symbol, excludeTypeOnlyMeanings, excludeLocalMeanings) {
-    const seen = new Set();
+    // Only a chain of aliases needs the set, so most calls never create it.
+    let seen;
     let flags = excludeLocalMeanings ? 0 /* SymbolFlags.None */ : symbol.flags;
     while ((symbol.flags & 2097152 /* SymbolFlags.Alias */) !== 0) {
         if (excludeTypeOnlyMeanings && getTypeOnlyAliasDeclaration(c, symbol) !== undefined)
@@ -1534,8 +1535,9 @@ function getSymbolFlagsEx(c, symbol, excludeTypeOnlyMeanings, excludeLocalMeanin
         if (target === c.unknownSymbol)
             return 1073741823 /* SymbolFlags.All */;
         if ((target.flags & 2097152 /* SymbolFlags.Alias */) !== 0) {
-            if (target === symbol || seen.has(target))
+            if (target === symbol || seen?.has(target))
                 break;
+            seen ??= new Set();
             seen.add(symbol);
             seen.add(target);
         }

package/dist/api/compiler/checker-source-file.js

@@ -520,7 +520,7 @@ function checkTypeMemberAccessor(c, node) {
 /** Variadic tuple elements must be array-like. */
 function checkTupleRestElements(c, node) {
     for (const e of node.elements.nodes) {
-        if ((getTupleElementFlags(c, e) & 8 /* ElementFlags.Variadic */) === 0)
+        if ((getTupleElementFlags(e) & 8 /* ElementFlags.Variadic */) === 0)
             continue;
         if (!isArrayLikeType(c, getTypeFromTypeNode(c, getType(e)))) {
             c.error(e, 732 /* Diagnostics.A_rest_element_type_must_be_an_array_type */);

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;
@@ -1708,18 +1749,27 @@ export function intersectTypes(c, type1, type2) {
 export function getIntersectionType(c, types) {
     return getIntersectionTypeEx(c, types, 0 /* IntersectionFlags.None */, undefined);
 }
+/**
+ * The distinct types of an intersection, in the order they were added. Most intersections have a few
+ * types, which a scan of `values` finds faster than a `Set` costs to build, so the set is created only
+ * once the list grows past `INDEX_AFTER`.
+ */
 class OrderedTypeSet {
+    static INDEX_AFTER = 8;
     values = [];
-    seen = new Set();
+    index;
     includes = 0;
     has(t) {
-        return this.seen.has(t);
+        return this.index !== undefined ? this.index.has(t) : this.values.includes(t);
     }
     add(t) {
-        if (!this.seen.has(t)) {
-            this.seen.add(t);
-            this.values.push(t);
-        }
+        if (this.has(t))
+            return;
+        this.values.push(t);
+        if (this.index !== undefined)
+            this.index.add(t);
+        else if (this.values.length > OrderedTypeSet.INDEX_AFTER)
+            this.index = new Set(this.values);
     }
 }
 function addTypesToIntersection(c, set, types) {
@@ -2085,7 +2135,8 @@ function getCrossProductIntersections(c, types, flags) {
  */
 function addCrossProductIntersections(c, types, flags, constituents, index, unit, intersections) {
     if (index === types.length) {
-        const t = getIntersectionTypeEx(c, constituents.slice(), flags, undefined);
+        // getIntersectionTypeEx copies the types it keeps, so the buffer is reused for the next combination.
+        const t = getIntersectionTypeEx(c, constituents, flags, undefined);
         if ((t.flags & 262144 /* TypeFlags.Never */) === 0)
             intersections.push(t);
         return;

package/dist/api/compiler/checker-type-nodes.d.ts

@@ -20,7 +20,7 @@ export declare function isTypeAlias(node: Node): boolean;
 export declare function getAliasForTypeNode(c: Checker, node: Node): TypeAlias | undefined;
 export declare function getAliasSymbolForTypeNode(c: Checker, node: Node): Symbol | undefined;
 export declare function getTypeAliasInstantiation(c: Checker, symbol: Symbol, typeArguments: Type[], alias: TypeAlias | undefined): Type;
-export declare function getTupleElementFlags(c: Checker, node: Node): ElementFlags;
+export declare function getTupleElementFlags(node: Node): ElementFlags;
 /** Type arguments of a deferred reference from its node. */
 export declare function getTypeArgumentsOfDeferredReference(c: Checker, node: Node, target: InterfaceType): Type[];
 /** The symbol an identifier resolves to, cached on the identifier. */

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

@@ -711,7 +711,7 @@ function getTypeFromTypeQueryNode(c, node) {
     }
     return type;
 }
-export function getTupleElementFlags(c, node) {
+export function getTupleElementFlags(node) {
     switch (node.kind) {
         case 192 /* SyntaxKind.OptionalType */:
             return 2 /* ElementFlags.Optional */;
@@ -730,8 +730,8 @@ export function getTupleElementFlags(c, node) {
     }
     return 1 /* ElementFlags.Required */;
 }
-function getTupleElementInfo(c, node) {
-    return new TupleElementInfo(getTupleElementFlags(c, node), node.kind === 204 /* SyntaxKind.NamedTupleMember */ || node.kind === 171 /* SyntaxKind.Parameter */ ? node : undefined);
+function getTupleElementInfo(node) {
+    return new TupleElementInfo(getTupleElementFlags(node), node.kind === 204 /* SyntaxKind.NamedTupleMember */ || node.kind === 171 /* SyntaxKind.Parameter */ ? node : undefined);
 }
 function getArrayElementTypeNode(node) {
     switch (node.kind) {
@@ -760,7 +760,7 @@ function getArrayOrTupleTargetType(c, node) {
         return readonly ? c.globalReadonlyArrayType : c.globalArrayType;
     const elementInfos = [];
     for (const e of node.elements.nodes)
-        elementInfos.push(getTupleElementInfo(c, e));
+        elementInfos.push(getTupleElementInfo(e));
     return getTupleTargetType(c, elementInfos, readonly);
 }
 function getTypeFromArrayOrTupleTypeNode(c, node) {
@@ -787,7 +787,7 @@ function getTypeFromArrayOrTupleTypeNode(c, node) {
 }
 function hasVariadicTupleElement(c, node) {
     for (const e of node.elements.nodes)
-        if ((getTupleElementFlags(c, e) & 8 /* ElementFlags.Variadic */) !== 0)
+        if ((getTupleElementFlags(e) & 8 /* ElementFlags.Variadic */) !== 0)
             return true;
     return false;
 }

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

@@ -326,8 +326,9 @@ function checkUnusedLocalsAndParameters(c, node) {
     const locals = getLocals(node);
     if (locals === undefined)
         return;
-    const variableParents = new Set();
-    const importClauses = new Map();
+    // Created on the first unused declaration: most scopes have none.
+    let variableParents;
+    let importClauses;
     for (const local of locals.values()) {
         const referenceKinds = c.symbolReferenceKinds.get(getSymbolId(local));
         if ((local.flags & 262144 /* SymbolFlags.TypeParameter */) !== 0) {
@@ -343,6 +344,7 @@ function checkUnusedLocalsAndParameters(c, node) {
                 case 262 /* SyntaxKind.VariableDeclaration */:
                 case 171 /* SyntaxKind.Parameter */:
                 case 210 /* SyntaxKind.BindingElement */:
+                    variableParents ??= new Set();
                     variableParents.add(getRootDeclaration(declaration).parent);
                     break;
                 case 275 /* SyntaxKind.ImportClause */:
@@ -350,6 +352,7 @@ function checkUnusedLocalsAndParameters(c, node) {
                 case 276 /* SyntaxKind.NamespaceImport */:
                     if (!isIdentifierThatStartsWithUnderscore(getName(declaration))) {
                         const importClause = importClauseFromImported(declaration);
+                        importClauses ??= new Map();
                         const unuseds = importClauses.get(importClause);
                         if (unuseds === undefined)
                             importClauses.set(importClause, [declaration]);
@@ -363,14 +366,16 @@ function checkUnusedLocalsAndParameters(c, node) {
             }
         }
     }
-    for (const declaration of variableParents) {
-        if (declaration.kind === 263 /* SyntaxKind.VariableDeclarationList */)
-            reportUnusedVariables(c, declaration, declaration.declarations.nodes);
-        else
-            reportUnusedVariableDeclarations(c, getParameters(declaration).nodes);
-    }
-    for (const [declaration, unuseds] of importClauses)
-        reportUnusedImports(c, declaration, unuseds);
+    if (variableParents !== undefined)
+        for (const declaration of variableParents) {
+            if (declaration.kind === 263 /* SyntaxKind.VariableDeclarationList */)
+                reportUnusedVariables(c, declaration, declaration.declarations.nodes);
+            else
+                reportUnusedVariableDeclarations(c, getParameters(declaration).nodes);
+        }
+    if (importClauses !== undefined)
+        for (const [declaration, unuseds] of importClauses)
+            reportUnusedImports(c, declaration, unuseds);
 }
 function reportUnusedLocal(c, node, name) {
     const message = isTypeDeclaration(node)

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';
@@ -154,6 +155,8 @@ export declare class Checker implements TypeChecking {
     readonly noUncheckedIndexedAccess: boolean;
     typeCount: number;
     signatureCount: number;
+    /** Transient symbols the checker created (statistics), as tsgo's `Checker.SymbolCount`. */
+    symbolCount: number;
     /** Positions of members by name in the tables and lists that lazily instantiated members come from. */
     readonly memberPositionsInLists: Map<Symbol[], Map<string, number>>;
     /** The property names of the last instantiation of each such list whose table is built on demand. */
@@ -225,6 +228,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 +279,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 +554,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. */
@@ -281,6 +282,8 @@ export class Checker {
     // Counters for type and signature ids.
     typeCount = 0;
     signatureCount = 0;
+    /** Transient symbols the checker created (statistics), as tsgo's `Checker.SymbolCount`. */
+    symbolCount = 0;
     /** Positions of members by name in the tables and lists that lazily instantiated members come from. */
     memberPositionsInLists = new Map();
     /** The property names of the last instantiation of each such list whose table is built on demand. */
@@ -358,6 +361,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 +414,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 +582,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 +892,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();
@@ -977,10 +984,12 @@ export class Checker {
         return new TypeParameter(this.nextTypeId(), symbol);
     }
     newSymbol(flags, name) {
+        this.symbolCount++;
         const symbol = new Symbol(flags | 33554432 /* SymbolFlags.Transient */, name);
         return symbol;
     }
     newSymbolWithCheckFlags(flags, name, checkFlags) {
+        this.symbolCount++;
         const symbol = new Symbol(flags | 33554432 /* SymbolFlags.Transient */, name);
         symbol.checkFlags = checkFlags;
         return symbol;
@@ -1059,6 +1068,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;
+}

package/dist/api/compiler/expr-record.js

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

package/dist/api/compiler/file-loader.d.ts

@@ -29,6 +29,11 @@ export declare class CompilerHost extends ModuleResolutionHost {
     readFile(path: string): string | undefined;
     realpath(path: string): string;
     getDirectories(path: string): readonly string[];
+    /**
+     * The metadata of the file `FileLoader` is parsing, which it computes from the file's package scope
+     * before it parses it; a host that walks the grammar of the parsed file reads it (parse-thread.ts).
+     */
+    loadingSourceFileMetadata: SourceFileMetadata | undefined;
     /** Parses a file, or returns `undefined` if it can't be read. */
     getSourceFile(fileName: string, path: string, externalModuleIndicatorOptions: ExternalModuleIndicatorOptions): SourceFile | undefined;
     /** The config of a referenced project, or `undefined` if it can't be read. */

package/dist/api/compiler/file-loader.js

@@ -51,6 +51,11 @@ export class CompilerHost extends ModuleResolutionHost {
     getDirectories(path) {
         return this.fs.getAccessibleEntries(path).directories;
     }
+    /**
+     * The metadata of the file `FileLoader` is parsing, which it computes from the file's package scope
+     * before it parses it; a host that walks the grammar of the parsed file reads it (parse-thread.ts).
+     */
+    loadingSourceFileMetadata = undefined;
     /** Parses a file, or returns `undefined` if it can't be read. */
     getSourceFile(fileName, path, externalModuleIndicatorOptions) {
         // A file that parse threads prepared (parallel-parse.ts).
@@ -1054,6 +1059,8 @@ export class FileLoader {
                 ? libFileMetadata
                 : (loaded?.metadata ?? this.loadSourceFileMetadata(task.normalizedFilePath));
         const options = this.mapper.getCompilerOptionsForFile(task.path, task.normalizedFilePath);
+        // For the host that walks the grammar of the file as it parses it (parse-thread.ts).
+        this.host.loadingSourceFileMetadata = task.metadata;
         const file = this.host.getSourceFile(task.normalizedFilePath, task.path, getExternalModuleIndicatorOptions(task.normalizedFilePath, options, task.metadata));
         if (file === undefined)
             return;

package/dist/api/compiler/identifier-name.d.ts

@@ -0,0 +1,9 @@
+import type { ProgramLifetime } from '@scriptc/types';
+/**
+ * The text of an identifier. The identifiers a parser's scanner interns with the same text share one
+ * (scanner.ts `IdentifierTable`), and natively an identifier refers to it in 4 bytes.
+ */
+export declare class IdentifierName implements ProgramLifetime {
+    readonly text: string;
+    constructor(text: string);
+}

package/dist/api/compiler/identifier-name.js

@@ -0,0 +1,10 @@
+/**
+ * The text of an identifier. The identifiers a parser's scanner interns with the same text share one
+ * (scanner.ts `IdentifierTable`), and natively an identifier refers to it in 4 bytes.
+ */
+export class IdentifierName {
+    text;
+    constructor(text) {
+        this.text = text;
+    }
+}