tsc-ts 0.0.10 → 0.1.1

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

@@ -1,26 +1,28 @@
-import type { DeferredCollisionCheck } from './checker-generated-code.js';
+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 { CompactSymbolLinkTable, IntLinkTable, LinkTable, PagedIdSet, SparseLinkTable } from './link-tables.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';
-import { IndexInfo, IntrinsicType, LiteralType, MemberNames, NodeLinks, ObjectFlags, ObjectType, Signature, SignatureFlags, SymbolLinks, type Type, TypeFlags, TypeMapper, TypeParameter, TypePredicate, VarianceFlags, TypeListCache, TypeListTable, type ConditionalType, type InterfaceType, type TypeChecking } from './checker-types.js';
+import { IndexInfo, IntrinsicType, LiteralType, MemberNames, NamedMemberOrder, NodeLinks, ObjectFlags, ObjectType, Signature, SignatureFlags, SymbolLinks, type Type, TypeFlags, TypeMapper, TypeParameter, TypePredicate, VarianceFlags, TypeListCache, TypeListTable, type ConditionalType, type InterfaceType, type TypeChecking, type ConditionalResultKey, type DistributedConditional } from './checker-types.js';
 import type { ModuleResolution } from './checker-modules.js';
 import { CheckerNameResolver, type LibGlobals, type MergedGlobals, TableChanges, SuggestionNameResolver } from './checker-symbols.js';
-import { Relation, RelationKey, type InternedRelationKey, type Relater, TypeComparer } from './relations.js';
+import { Relation, RelationKey, type InternedRelationKey, type Relater, TypeComparer, type VarianceStackEntry } from './relations.js';
 import { TypeNodeVisitor } from './checker-source-file.js';
 import { InferenceCaches } from './checker-inference.js';
 import { AssignmentMarker, type FlowLoopInfo, type FlowState, type FlowWalk } from './checker-narrowing.js';
 import type { FlowNode, FlowReduceLabel } from './flow.js';
 import { JsxState } from './checker-jsx.js';
-import type { DeferredIterationError, IterationTypes } from './checker-iteration.js';
+import type { IterationTypes } from './checker-iteration.js';
 import type { SpreadIndices } from './checker-contextual.js';
 import { SourceFileMetadata } from './program-utilities.js';
 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 { type ThreadSharing } from './shared-results.js';
 /** What the checker needs from a program. */
 export declare abstract class CheckerHost {
     abstract getCompilerOptions(): CompilerOptions;
@@ -57,15 +59,21 @@ export declare abstract class CheckerHost {
     /** What module specifier generation needs; without it, specifiers are relative paths. */
     getModuleSpecifierHost(): ModuleSpecifierHost | undefined;
 }
-/** Per-file and global diagnostics, sorted on read like tsgo's DiagnosticsCollection. */
+/**
+ * Per-file and global diagnostics, sorted on read like tsgo's DiagnosticsCollection, which keeps one of
+ * each set of equal diagnostics.
+ */
 declare class DiagnosticCollection {
     private readonly byFile;
     private readonly sortedFiles;
     private readonly global;
     private globalSorted;
-    /** The diagnostics added since `startLog`, while recording. */
+    /** The diagnostics at each file, position, end and code, to find an equal one when adding. */
+    private readonly byLocation;
+    /** The diagnostics reported since `startLog`, while recording, also those equal to one already added. */
     private log;
-    add(diagnostic: Diagnostic): void;
+    /** Adds `diagnostic` unless an equal one was added; returns the one the collection holds. */
+    add(diagnostic: Diagnostic): Diagnostic;
     forFile(fileName: string): Diagnostic[];
     count(): number;
     /** An already reported diagnostic equal to `diagnostic`, if any. */
@@ -73,8 +81,12 @@ declare class DiagnosticCollection {
     globals(): Diagnostic[];
     /** The global diagnostics `withoutNewGlobals` removed. */
     removedGlobals: number;
+    /** Where results are shared between checker threads (shared-results.ts): every diagnostic added, in order. */
+    added: Diagnostic[] | undefined;
     /** Runs `run`, then removes the global diagnostics it added. */
     withoutNewGlobals<T>(run: () => T): T;
+    /** Removes the global diagnostic `diagnostic` from the location index. */
+    private forget;
     /** Records the diagnostics added from now on. */
     startLog(): void;
     /** The diagnostics added since `startLog`, in order; stops recording. */
@@ -147,10 +159,20 @@ export declare class Checker implements TypeChecking {
     readonly memberPositionsInLists: Map<Symbol[], Map<string, number>>;
     /** The property names of the last instantiation of each such list whose table is built on demand. */
     readonly memberNamesOfLists: Map<Symbol[], MemberNames>;
+    /** The property order of the instantiations of each such list (`NamedMemberOrder`); null where it has none. */
+    readonly namedMemberOrdersOfLists: Map<Symbol[], NamedMemberOrder | null>;
     /** Long lists of inherited properties, by name. */
     readonly propertiesByName: Map<Symbol[], Map<string, Symbol>>;
     /** Number of `typeToString` calls in progress. */
     serializationLevel: number;
+    /**
+     * `typeToString` results by type, enclosing declaration, flags and the type parameter of the variance check in
+     * progress: the prints that created no types, which a later print with the same inputs repeats exactly
+     * (`typeToString`).
+     */
+    readonly typeStrings: Map<string, string>;
+    /** `symbolToString` results by symbol, then by enclosing declaration and flags, kept as `typeStrings` are. */
+    readonly symbolStrings: Map<Symbol, Map<string, string>>;
     /** Whether `globalObjectType` is set; global type lookups before it can't suggest `typeof`. */
     hasGlobalObjectType: boolean;
     /** The node being checked, for errors with no better location. */
@@ -167,7 +189,7 @@ export declare class Checker implements TypeChecking {
      */
     modulesMerged: boolean;
     /** Module specifiers of `import("…")` types, by module symbol id, importing file path and resolution mode. */
-    readonly moduleSpecifiers: Map<string, string>;
+    readonly moduleSpecifiers: Map<string, ModuleSpecifierResult>;
     /** Specifier generation for hosts without a program. */
     fallbackModuleSpecifierHost: ModuleSpecifierHost | undefined;
     readonly symbolLinkTable: SparseLinkTable<SymbolLinks>;
@@ -188,24 +210,26 @@ export declare class Checker implements TypeChecking {
     /** The mapper of an instantiated symbol or a mapped type property. */
     readonly symbolMappers: LinkTable<TypeMapper>;
     /** The literal type of a property name. */
-    readonly symbolNameTypes: LinkTable<Type>;
+    readonly symbolNameTypes: CompactLinkTable<Type>;
     /** The mapped type of a mapped type property, or the union/intersection of a synthetic property. */
-    readonly symbolContainingTypes: LinkTable<Type>;
+    readonly symbolContainingTypes: CompactLinkTable<Type>;
     /** The key type of a mapped type property. */
-    readonly symbolKeyTypes: LinkTable<Type>;
+    readonly symbolKeyTypes: CompactLinkTable<Type>;
     /** The property a mapped, spread or synthetic property comes from. */
-    readonly symbolSyntheticOrigins: LinkTable<Symbol>;
+    readonly symbolSyntheticOrigins: CompactLinkTable<Symbol>;
     /** The left and right properties a spread property combines. */
-    readonly symbolLeftSpreads: LinkTable<Symbol>;
-    readonly symbolRightSpreads: LinkTable<Symbol>;
+    readonly symbolLeftSpreads: CompactLinkTable<Symbol>;
+    readonly symbolRightSpreads: CompactLinkTable<Symbol>;
     /** Bits of SymbolFlags for the meanings in which a symbol was referenced. */
-    readonly symbolReferenceKinds: IntLinkTable;
+    readonly symbolReferenceKinds: CompactIntLinkTable;
     /** The resolved symbol of an identifier, entity name or call. */
-    readonly resolvedSymbols: CompactSymbolLinkTable;
+    readonly resolvedSymbols: CompactLinkTable<Symbol>;
     /** The resolved type of a type node or expression. */
-    readonly resolvedTypes: SparseLinkTable<Type>;
+    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: SparseLinkTable<Signature>;
+    readonly resolvedSignatures: CompactLinkTable<Signature>;
     /** Merged symbols, indexed by the id of the symbol merged into them. */
     readonly mergedSymbols: Map<number, Symbol>;
     /**
@@ -253,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>;
@@ -368,13 +393,19 @@ export declare class Checker implements TypeChecking {
     readonly moduleTypeCache: Map<string, Type>;
     readonly globalSymbolCache: Map<string, Symbol | null>;
     resolutionStart: number;
-    inVarianceComputation: boolean;
+    /** The generic types whose variances are being computed, outermost first. */
+    varianceStack: VarianceStackEntry[];
     instantiationDepth: number;
+    /** The types being instantiated, outermost first: the first `instantiationDepth` entries are current. */
+    readonly instantiationStack: Type[];
+    /** The calls being resolved, outermost first: the first `callResolutionDepth` entries are current. */
+    readonly callResolutionStack: Node[];
+    callResolutionDepth: number;
     instantiationCount: number;
     /** Instantiations over the checker's lifetime (statistics). */
     totalInstantiations: number;
-    /** Mappers of the instantiations in progress: the first `activeMapperDepth` entries are live. */
-    readonly activeMappers: TypeMapper[];
+    /** Ids of the mappers of the instantiations in progress: the first `activeMapperDepth` entries are live. */
+    activeMapperIds: Int32Array<ArrayBuffer>;
     activeMapperDepth: number;
     /** Per active mapper: its instantiations by type id, created on the first nested write. */
     readonly activeMapperCaches: (Map<number, Type> | undefined)[];
@@ -389,20 +420,28 @@ export declare class Checker implements TypeChecking {
     /** Empty lists for type arguments that are compared with cached instantiations before any is kept. */
     readonly freeTypeLists: Type[][];
     /**
-     * 1 by type id for the anonymous and mapped types whose declaration has no outer type parameters
+     * The ids of the anonymous and mapped types whose declaration has no outer type parameters
      * to instantiate (`getObjectTypeInstantiation`).
      */
-    readonly withoutOuterTypeParameters: IntLinkTable;
+    readonly withoutOuterTypeParameters: PagedIdSet;
     conditionalConstraintDepth: number;
     readonly suggestionResolver: SuggestionNameResolver;
     readonly awaitedTypeStack: number[];
     /** Iteration types by type id and iteration use. */
     readonly iterationTypesCache: Map<number, IterationTypes>;
-    /** Whether diagnostics can be deferred to the end of the file being checked. */
-    saveDeferredDiagnostics: boolean;
-    deferredIterationErrors: DeferredIterationError[];
-    /** Collision checks waiting for the end of the file (checker-generated-code.ts). */
-    deferredCollisionChecks: DeferredCollisionCheck[];
+    /**
+     * Diagnostics reported after the checks of the file being checked, or before the next global
+     * diagnostics are read, in the order they were deferred. Reporting them earlier could resolve types
+     * that are being resolved.
+     */
+    deferredDiagnostics: (() => void)[];
+    /** Defers the diagnostic `report` reports at `node` (`deferredDiagnostics`). */
+    deferDiagnostic(node: Node, report: () => void): void;
+    /**
+     * The checked object literals of each file whose members may set deprecated properties of their contextual
+     * types, reported when the file's suggestion diagnostics are asked for (`checkObjectLiteralDeprecations`).
+     */
+    readonly objectLiteralsForDeprecations: Map<SourceFile, Node[]>;
     /** Binding patterns whose implied type is being computed as a contextual type. */
     readonly contextualBindingPatterns: Node[];
     /** The binding pattern or assignment pattern that implied each type. */
@@ -453,11 +492,13 @@ export declare class Checker implements TypeChecking {
     flowTypeCache: Map<Node, Type> | undefined;
     flowInvocationCount: number;
     /** The reduce labels being passed, innermost last; each limits its target label's antecedents. */
-    readonly flowReduceLabels: FlowReduceLabel[];
+    flowReduceLabels: FlowReduceLabel[];
     readonly flowNodeReachable: Map<FlowNode, boolean>;
     readonly flowNodePostSuper: Map<FlowNode, boolean>;
     lastFlowNode: FlowNode | undefined;
     lastFlowNodeReachable: boolean;
+    /** Symbols whose explicit type is being found, for flow analysis of self-referential `for...of`. */
+    readonly resolvingExplicitTypeOfSymbol: Set<Symbol>;
     readonly assignmentMarker: AssignmentMarker;
     readonly primitiveTypeAliasSuggestions: Map<string, Symbol>;
     /** Renamed binding elements in parameters of bodiless signatures, checked for use with their file. */
@@ -480,6 +521,9 @@ export declare class Checker implements TypeChecking {
     readonly ambientModuleSymbols: Symbol[];
     readonly patternAmbientModules: PatternAmbientModule[];
     readonly patternAmbientModuleAugmentations: Map<string, Symbol>;
+    /** The pattern module each entry of `patternAmbientModuleAugmentations` augments. */
+    readonly patternAmbientModuleAugmentationTargets: Map<string, Symbol>;
+    readonly moduleImportAttributesTypes: Map<Symbol, Type>;
     readonly inferenceCaches: InferenceCaches;
     /** The type resolution stack: the first `resolutionDepth` entries are live, later slots are reused. */
     readonly resolutionTargets: (Symbol | Type | Signature | Node)[];
@@ -488,6 +532,27 @@ export declare class Checker implements TypeChecking {
     resolutionDepth: number;
     /** The number of resolution cycles found (`pushTypeResolution`). */
     resolutionCycleCount: number;
+    /**
+     * While an `inferTypesFromUnstarted` walk runs: the unions and intersections whose properties
+     * `hasUnmatchedProperty` searched before they were resolved. Such a search creates fewer types
+     * than one of the resolved properties.
+     */
+    unresolvedPropertySearches: Type[] | undefined;
+    /** TSC_TS_SHARE: the checker thread's sharing with the other checker threads. */
+    threadSharing: ThreadSharing | undefined;
+    /**
+     * Where results are shared (shared-results.ts): for each conditional type made as a member of the distribution of a
+     * conditional type instantiation, that instantiation and the constituent it is for.
+     */
+    distributedConditionals: Map<Type, DistributedConditional> | undefined;
+    /** The same members by `distributedKey`. */
+    distributedByKey: Map<string, Type> | undefined;
+    /** The conditional types conditional type instantiations resolved to, with the instantiation's root and key. */
+    conditionalResults: Map<Type, ConditionalResultKey> | undefined;
+    /** 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: number[] | undefined;
     constructor(host: CheckerHost);
     /** Checks `file` if needed and returns its semantic diagnostics, sorted. */
     getDiagnostics(file: SourceFile): Diagnostic[];
@@ -522,7 +587,8 @@ export declare class Checker implements TypeChecking {
     newSignature(flags: SignatureFlags, declaration: Node | undefined, typeParameters: Type[], thisParameter: Symbol | undefined, parameters: Symbol[], resolvedReturnType: Type | undefined, minArgumentCount: number): Signature;
     /** Reports `message` at `node`, or as a global diagnostic without a node. */
     error(node: Node | undefined, message: DiagnosticMessage, ...args: string[]): Diagnostic;
-    addDiagnostic(diagnostic: Diagnostic): void;
+    /** Reports `diagnostic`; returns the equal diagnostic already reported, if any, else `diagnostic`. */
+    addDiagnostic(diagnostic: Diagnostic): Diagnostic;
     addSuggestion(diagnostic: Diagnostic): void;
     /** Reports an error, or a suggestion when `isError` is false. */
     addErrorOrSuggestion(isError: boolean, diagnostic: Diagnostic): void;

package/dist/api/compiler/checker.js

@@ -1,7 +1,8 @@
 import { sideOf } from './side-state.js';
-import { CompactSymbolLinkTable, IntLinkTable, LinkTable, PagedIdSet, SparseLinkTable } from './link-tables.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 } from './diagnostics.js';
+import { Diagnostic, compareDiagnostics, equalDiagnostics, } from './diagnostics.js';
 import { ModuleKind, ScriptTarget, getEmitScriptTarget, getIsolatedModules, getStrictOptionValue, shouldPreserveConstEnums, } from './options.js';
 import { Symbol, getSymbolId } from './symbol.js';
 import { IndexInfo, IntrinsicType, LiteralType, NodeLinks, Signature, SymbolLinks, TypeParameter, TypePredicate, emptyTypes, TypeListCache, TypeListTable, } from './checker-types.js';
@@ -10,12 +11,14 @@ import { getFalseTypeFromConditionalType, getTrueTypeFromConditionalType } from
 import { createArrayType, createTypeFromGenericGlobalType, getBigIntLiteralType, getNumberLiteralType, getStringLiteralType, getTemplateLiteralType, getUnionType, newAnonymousType, newObjectType, } from './checker-type-factory.js';
 import { CheckerNameResolver, borrowLibGlobals, findLibGlobals, returnLibGlobals, setGlobal, SuggestionNameResolver, getGlobalStrictFunctionType, getGlobalType, initializeGlobals, mergeAmbientModulesAndAugmentations, } from './checker-symbols.js';
 import { PermissiveMapper, ReportingMapper, RestrictiveMapper, UniqueLiteralMapper } from './instantiation.js';
-import { Relation, RelationKey } from './relations.js';
-import { TypeNodeVisitor, checkSourceFile } from './checker-source-file.js';
+import { Relation, RelationKey, } from './relations.js';
+import { TypeNodeVisitor, checkSourceFile, produceDeferredDiagnostics } from './checker-source-file.js';
+import { checkObjectLiteralDeprecations } from './checker-deprecation.js';
 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 { 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. */
@@ -78,22 +81,40 @@ export class CheckerHost {
         return undefined;
     }
 }
-/** Per-file and global diagnostics, sorted on read like tsgo's DiagnosticsCollection. */
+/**
+ * Per-file and global diagnostics, sorted on read like tsgo's DiagnosticsCollection, which keeps one of
+ * each set of equal diagnostics.
+ */
 class DiagnosticCollection {
     byFile = new Map();
     sortedFiles = new Set();
     global = [];
     globalSorted = true;
-    /** The diagnostics added since `startLog`, while recording. */
+    /** The diagnostics at each file, position, end and code, to find an equal one when adding. */
+    byLocation = new Map();
+    /** The diagnostics reported since `startLog`, while recording, also those equal to one already added. */
     log = undefined;
+    /** Adds `diagnostic` unless an equal one was added; returns the one the collection holds. */
     add(diagnostic) {
         if (this.log !== undefined)
             this.log.push(diagnostic);
+        if (this.added !== undefined)
+            this.added.push(diagnostic);
         const file = diagnostic.file;
+        const key = `${file === undefined ? '' : file.fileName}\0${diagnostic.pos}\0${diagnostic.end}\0${diagnostic.code}`;
+        const existing = this.byLocation.get(key);
+        if (existing === undefined)
+            this.byLocation.set(key, [diagnostic]);
+        else {
+            for (const d of existing)
+                if (equalDiagnostics(d, diagnostic))
+                    return d;
+            existing.push(diagnostic);
+        }
         if (file === undefined) {
             this.global.push(diagnostic);
             this.globalSorted = false;
-            return;
+            return diagnostic;
         }
         let list = this.byFile.get(file.fileName);
         if (list === undefined) {
@@ -102,6 +123,7 @@ class DiagnosticCollection {
         }
         list.push(diagnostic);
         this.sortedFiles.delete(file.fileName);
+        return diagnostic;
     }
     forFile(fileName) {
         const list = this.byFile.get(fileName);
@@ -139,6 +161,8 @@ class DiagnosticCollection {
     }
     /** The global diagnostics `withoutNewGlobals` removed. */
     removedGlobals = 0;
+    /** Where results are shared between checker threads (shared-results.ts): every diagnostic added, in order. */
+    added = undefined;
     /** Runs `run`, then removes the global diagnostics it added. */
     withoutNewGlobals(run) {
         const outer = this.log;
@@ -157,15 +181,28 @@ class DiagnosticCollection {
                 if (d.file === undefined)
                     globals.add(d);
             if (globals.size > 0) {
-                this.removedGlobals += globals.size;
                 let kept = 0;
-                for (const d of this.global)
+                for (const d of this.global) {
                     if (!globals.has(d))
                         this.global[kept++] = d;
+                    else
+                        this.forget(d);
+                }
+                this.removedGlobals += this.global.length - kept;
                 this.global.length = kept;
             }
         }
     }
+    /** Removes the global diagnostic `diagnostic` from the location index. */
+    forget(diagnostic) {
+        const key = `\0${diagnostic.pos}\0${diagnostic.end}\0${diagnostic.code}`;
+        const existing = this.byLocation.get(key);
+        if (existing === undefined)
+            return;
+        const at = existing.indexOf(diagnostic);
+        if (at >= 0)
+            existing.splice(at, 1);
+    }
     /** Records the diagnostics added from now on. */
     startLog() {
         this.log = [];
@@ -249,10 +286,20 @@ export class Checker {
     memberPositionsInLists = new Map();
     /** The property names of the last instantiation of each such list whose table is built on demand. */
     memberNamesOfLists = new Map();
+    /** The property order of the instantiations of each such list (`NamedMemberOrder`); null where it has none. */
+    namedMemberOrdersOfLists = new Map();
     /** Long lists of inherited properties, by name. */
     propertiesByName = new Map();
     /** Number of `typeToString` calls in progress. */
     serializationLevel = 0;
+    /**
+     * `typeToString` results by type, enclosing declaration, flags and the type parameter of the variance check in
+     * progress: the prints that created no types, which a later print with the same inputs repeats exactly
+     * (`typeToString`).
+     */
+    typeStrings = new Map();
+    /** `symbolToString` results by symbol, then by enclosing declaration and flags, kept as `typeStrings` are. */
+    symbolStrings = new Map();
     /** Whether `globalObjectType` is set; global type lookups before it can't suggest `typeof`. */
     hasGlobalObjectType = false;
     /** The node being checked, for errors with no better location. */
@@ -286,6 +333,9 @@ export class Checker {
      * so far; null where a list repeats a name.
      */
     propertyListIndexes = new Map();
+    // Types, targets and mappers of symbols keep a slot per id: they are dense enough, and read on hot
+    // paths. The other symbol columns, which most symbols leave empty, keep only their values
+    // (CompactLinkTable).
     /** The type of a value symbol. */
     symbolTypes = new LinkTable();
     /** For instantiated and synthetic symbols, the symbol they come from. */
@@ -293,24 +343,26 @@ export class Checker {
     /** The mapper of an instantiated symbol or a mapped type property. */
     symbolMappers = new LinkTable();
     /** The literal type of a property name. */
-    symbolNameTypes = new LinkTable();
+    symbolNameTypes = new CompactLinkTable();
     /** The mapped type of a mapped type property, or the union/intersection of a synthetic property. */
-    symbolContainingTypes = new LinkTable();
+    symbolContainingTypes = new CompactLinkTable();
     /** The key type of a mapped type property. */
-    symbolKeyTypes = new LinkTable();
+    symbolKeyTypes = new CompactLinkTable();
     /** The property a mapped, spread or synthetic property comes from. */
-    symbolSyntheticOrigins = new LinkTable();
+    symbolSyntheticOrigins = new CompactLinkTable();
     /** The left and right properties a spread property combines. */
-    symbolLeftSpreads = new LinkTable();
-    symbolRightSpreads = new LinkTable();
+    symbolLeftSpreads = new CompactLinkTable();
+    symbolRightSpreads = new CompactLinkTable();
     /** Bits of SymbolFlags for the meanings in which a symbol was referenced. */
-    symbolReferenceKinds = new IntLinkTable();
+    symbolReferenceKinds = new CompactIntLinkTable();
     /** The resolved symbol of an identifier, entity name or call. */
-    resolvedSymbols = new CompactSymbolLinkTable();
+    resolvedSymbols = new CompactLinkTable();
     /** The resolved type of a type node or expression. */
-    resolvedTypes = new SparseLinkTable();
+    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 SparseLinkTable();
+    resolvedSignatures = new CompactLinkTable();
     /** Merged symbols, indexed by the id of the symbol merged into them. */
     mergedSymbols;
     /**
@@ -360,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();
@@ -480,14 +533,20 @@ export class Checker {
     globalSymbolCache = new Map();
     // Resolution stacks for cycle detection (see pushTypeResolution).
     resolutionStart = 0;
-    inVarianceComputation = false;
+    /** The generic types whose variances are being computed, outermost first. */
+    varianceStack = [];
     // Instantiation
     instantiationDepth = 0;
+    /** The types being instantiated, outermost first: the first `instantiationDepth` entries are current. */
+    instantiationStack = [];
+    /** The calls being resolved, outermost first: the first `callResolutionDepth` entries are current. */
+    callResolutionStack = [];
+    callResolutionDepth = 0;
     instantiationCount = 0;
     /** Instantiations over the checker's lifetime (statistics). */
     totalInstantiations = 0;
-    /** Mappers of the instantiations in progress: the first `activeMapperDepth` entries are live. */
-    activeMappers = [];
+    /** Ids of the mappers of the instantiations in progress: the first `activeMapperDepth` entries are live. */
+    activeMapperIds = new Int32Array(16);
     activeMapperDepth = 0;
     /** Per active mapper: its instantiations by type id, created on the first nested write. */
     activeMapperCaches = [];
@@ -502,20 +561,32 @@ export class Checker {
     /** Empty lists for type arguments that are compared with cached instantiations before any is kept. */
     freeTypeLists = [];
     /**
-     * 1 by type id for the anonymous and mapped types whose declaration has no outer type parameters
+     * The ids of the anonymous and mapped types whose declaration has no outer type parameters
      * to instantiate (`getObjectTypeInstantiation`).
      */
-    withoutOuterTypeParameters = new IntLinkTable();
+    withoutOuterTypeParameters = new PagedIdSet();
     conditionalConstraintDepth = 0;
     suggestionResolver;
     awaitedTypeStack = [];
     /** Iteration types by type id and iteration use. */
     iterationTypesCache = new Map();
-    /** Whether diagnostics can be deferred to the end of the file being checked. */
-    saveDeferredDiagnostics = false;
-    deferredIterationErrors = [];
-    /** Collision checks waiting for the end of the file (checker-generated-code.ts). */
-    deferredCollisionChecks = [];
+    /**
+     * Diagnostics reported after the checks of the file being checked, or before the next global
+     * diagnostics are read, in the order they were deferred. Reporting them earlier could resolve types
+     * that are being resolved.
+     */
+    deferredDiagnostics = [];
+    /** Defers the diagnostic `report` reports at `node` (`deferredDiagnostics`). */
+    deferDiagnostic(node, report) {
+        this.deferredDiagnostics.push(report);
+        if (this.deferredDiagnosticFiles !== undefined)
+            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
+     * types, reported when the file's suggestion diagnostics are asked for (`checkObjectLiteralDeprecations`).
+     */
+    objectLiteralsForDeprecations = new Map();
     /** Binding patterns whose implied type is being computed as a contextual type. */
     contextualBindingPatterns = [];
     /** The binding pattern or assignment pattern that implied each type. */
@@ -572,6 +643,8 @@ export class Checker {
     flowNodePostSuper = new Map();
     lastFlowNode = undefined;
     lastFlowNodeReachable = false;
+    /** Symbols whose explicit type is being found, for flow analysis of self-referential `for...of`. */
+    resolvingExplicitTypeOfSymbol = new Set();
     assignmentMarker;
     primitiveTypeAliasSuggestions = new Map();
     /** Renamed binding elements in parameters of bodiless signatures, checked for use with their file. */
@@ -595,6 +668,9 @@ export class Checker {
     ambientModuleSymbols = [];
     patternAmbientModules = [];
     patternAmbientModuleAugmentations = new Map();
+    /** The pattern module each entry of `patternAmbientModuleAugmentations` augments. */
+    patternAmbientModuleAugmentationTargets = new Map();
+    moduleImportAttributesTypes = new Map();
     inferenceCaches = new InferenceCaches();
     /** The type resolution stack: the first `resolutionDepth` entries are live, later slots are reused. */
     resolutionTargets = [];
@@ -603,6 +679,28 @@ export class Checker {
     resolutionDepth = 0;
     /** The number of resolution cycles found (`pushTypeResolution`). */
     resolutionCycleCount = 0;
+    /**
+     * While an `inferTypesFromUnstarted` walk runs: the unions and intersections whose properties
+     * `hasUnmatchedProperty` searched before they were resolved. Such a search creates fewer types
+     * than one of the resolved properties.
+     */
+    unresolvedPropertySearches = undefined;
+    // The fields of shared results come last, so the fields before keep their places.
+    /** TSC_TS_SHARE: the checker thread's sharing with the other checker threads. */
+    threadSharing = undefined;
+    /**
+     * Where results are shared (shared-results.ts): for each conditional type made as a member of the distribution of a
+     * conditional type instantiation, that instantiation and the constituent it is for.
+     */
+    distributedConditionals = undefined;
+    /** The same members by `distributedKey`. */
+    distributedByKey = undefined;
+    /** The conditional types conditional type instantiations resolved to, with the instantiation's root and key. */
+    conditionalResults = undefined;
+    /** The access flags of the key `getIndexedAccessTypeEx` keeps each indexed access type by. */
+    indexedAccessKeyFlags = undefined;
+    /** Where results are shared between checker threads (shared-results.ts): the file of each diagnostic deferred. */
+    deferredDiagnosticFiles = undefined;
     constructor(host) {
         this.host = host;
         const options = host.getCompilerOptions();
@@ -792,6 +890,15 @@ export class Checker {
         mergeAmbientModulesAndAugmentations(this);
         this.modulesMerged = true;
         this.mergeDiagnostics.push(this.diagnostics.takeLog(), this.suggestionDiagnostics.takeLog());
+        // 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();
+            this.conditionalResults = new Map();
+            this.indexedAccessKeyFlags = new Map();
+        }
     }
     // ---- Public API
     /** Checks `file` if needed and returns its semantic diagnostics, sorted. */
@@ -803,10 +910,12 @@ export class Checker {
     /** Checks `file`, including unused identifiers, and returns its suggestion diagnostics. */
     getSuggestionDiagnostics(file) {
         checkSourceFile(this, file, true);
+        checkObjectLiteralDeprecations(this, file);
         return this.suggestionDiagnostics.forFile(file.fileName);
     }
     /** Diagnostics without a file, such as missing global types. */
     getGlobalDiagnostics() {
+        produceDeferredDiagnostics(this);
         return this.diagnostics.globals();
     }
     /**
@@ -887,15 +996,15 @@ export class Checker {
     // ---- Diagnostics
     /** Reports `message` at `node`, or as a global diagnostic without a node. */
     error(node, message, ...args) {
-        const diagnostic = createDiagnosticForNode(node, message, args);
-        this.addDiagnostic(diagnostic);
-        return diagnostic;
+        return this.addDiagnostic(createDiagnosticForNode(node, message, args));
     }
+    /** Reports `diagnostic`; returns the equal diagnostic already reported, if any, else `diagnostic`. */
     addDiagnostic(diagnostic) {
         this.reports++;
         // Discard diagnostics created while at the maximum number of nested typeToString calls.
         if (this.serializationLevel < maxSerializationLevel)
-            this.diagnostics.add(diagnostic);
+            return this.diagnostics.add(diagnostic);
+        return diagnostic;
     }
     addSuggestion(diagnostic) {
         this.reports++;
@@ -941,6 +1050,7 @@ export function disposeChecker(c) {
     c.sharedSymbolCopies.clear();
     c.memberPositionsInLists.clear();
     c.memberNamesOfLists.clear();
+    c.namedMemberOrdersOfLists.clear();
     c.propertiesByName.clear();
     c.symbolAccessibilityCaches = undefined;
     c.unresolvedSymbols.clear();
@@ -954,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();
@@ -966,8 +1077,8 @@ export function disposeChecker(c) {
     c.cachedTypesById.clear();
     c.cachedTypesByPair.clear();
     c.iterationTypesCache.clear();
-    c.deferredIterationErrors = [];
-    c.deferredCollisionChecks = [];
+    c.deferredDiagnostics = [];
+    c.objectLiteralsForDeprecations.clear();
     c.errorTypes.clear();
     c.globalTypeCache.clear();
     c.globalSymbolCache.clear();
@@ -978,8 +1089,11 @@ export function disposeChecker(c) {
     c.flowNodePostSuper.clear();
     c.primitiveTypeAliasSuggestions.clear();
     c.patternAmbientModuleAugmentations.clear();
+    c.patternAmbientModuleAugmentationTargets.clear();
+    c.moduleImportAttributesTypes.clear();
     c.sharedFlowTypes.length = 0;
     c.relationComparers = [];
+    c.inferenceCaches.unstartedInferences.clear();
 }
 /** A diagnostic at `node`'s error range, or a global one without a node. */
 export function createDiagnosticForNode(node, message, args) {