tsc-ts 0.0.5 → 0.0.7

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

@@ -20,21 +20,6 @@ export class TypeAlias {
         this.typeArguments = typeArguments;
     }
 }
-/** One entry of a `TypeListCache`: the parts of its key, its value, and the next entry with the same hash. */
-class TypeListEntry {
-    types;
-    alias;
-    tag;
-    value;
-    next;
-    constructor(types, alias, tag, value) {
-        this.types = types;
-        this.alias = alias;
-        this.tag = tag;
-        this.value = value;
-        this.next = undefined;
-    }
-}
 function sameTypeListParts(a, b) {
     if (a.length !== b.length)
         return false;
@@ -53,32 +38,149 @@ function sameAliasParts(a, b) {
  * aliasKey(alias)` plus a suffix spelled, without building them. A lookup takes a number hashing the
  * parts (`typeListHash`); entries keep their parts, so a match is exact and keys sharing a hash chain.
  * Like tsgo's hashed type list keys. A list must not change after it keys an entry.
+ *
+ * Entries are numbered in the order they are added: `heads` maps a hash to its first entry, and the
+ * lists and values of the entries are kept in arrays by number. Aliases, tags and the chains of
+ * entries that share a hash get arrays once an entry needs them.
  */
 export class TypeListCache {
-    entries = new Map();
+    heads;
+    lists;
+    values;
+    aliases;
+    tags;
+    /** The next entry with the same hash, or -1. */
+    nexts;
+    constructor() {
+        this.heads = new Map();
+        this.lists = [];
+        this.values = [];
+        this.aliases = undefined;
+        this.tags = undefined;
+        this.nexts = undefined;
+    }
     get(hash, types, alias, tag) {
-        for (let e = this.entries.get(hash); e !== undefined; e = e.next)
-            if (e.tag === tag && sameTypeListParts(e.types, types) && sameAliasParts(e.alias, alias))
-                return e.value;
-        return undefined;
+        const entry = this.find(hash, types, alias, tag);
+        return entry >= 0 ? this.values[entry] : undefined;
     }
     set(hash, types, alias, tag, value) {
-        const head = this.entries.get(hash);
+        const head = this.heads.get(hash);
+        if (head !== undefined) {
+            const entry = this.findFrom(head, types, alias, tag);
+            if (entry >= 0) {
+                this.values[entry] = value;
+                return;
+            }
+        }
+        const entry = this.lists.length;
+        this.lists.push(types);
+        this.values.push(value);
+        const aliases = this.aliases;
+        if (aliases !== undefined)
+            aliases.push(alias);
+        else if (alias !== undefined) {
+            const created = [];
+            for (let i = 0; i < entry; i++)
+                created.push(undefined);
+            created.push(alias);
+            this.aliases = created;
+        }
+        const tags = this.tags;
+        if (tags !== undefined)
+            tags.push(tag);
+        else if (tag !== 0) {
+            const created = [];
+            for (let i = 0; i < entry; i++)
+                created.push(0);
+            created.push(tag);
+            this.tags = created;
+        }
+        let nexts = this.nexts;
+        if (nexts !== undefined)
+            nexts.push(-1);
         if (head === undefined) {
-            this.entries.set(hash, new TypeListEntry(types, alias, tag, value));
+            this.heads.set(hash, entry);
             return;
         }
-        for (let e = head; e !== undefined; e = e.next)
-            if (e.tag === tag && sameTypeListParts(e.types, types) && sameAliasParts(e.alias, alias)) {
-                e.value = value;
-                return;
-            }
-        const entry = new TypeListEntry(types, alias, tag, value);
-        entry.next = head.next;
-        head.next = entry;
+        // A second entry with this hash: chain it after the first.
+        if (nexts === undefined) {
+            nexts = [];
+            for (let i = 0; i <= entry; i++)
+                nexts.push(-1);
+            this.nexts = nexts;
+        }
+        nexts[entry] = nexts[head];
+        nexts[head] = entry;
     }
     clear() {
-        this.entries.clear();
+        this.heads = new Map();
+        this.lists = [];
+        this.values = [];
+        this.aliases = undefined;
+        this.tags = undefined;
+        this.nexts = undefined;
+    }
+    /** The number of the entry with these parts, or -1. */
+    find(hash, types, alias, tag) {
+        const head = this.heads.get(hash);
+        return head !== undefined ? this.findFrom(head, types, alias, tag) : -1;
+    }
+    findFrom(head, types, alias, tag) {
+        const tags = this.tags;
+        const aliases = this.aliases;
+        const nexts = this.nexts;
+        for (let entry = head; entry >= 0; entry = nexts !== undefined ? nexts[entry] : -1)
+            if ((tags !== undefined ? tags[entry] : 0) === tag &&
+                sameTypeListParts(this.lists[entry], types) &&
+                sameAliasParts(aliases !== undefined ? aliases[entry] : undefined, alias))
+                return entry;
+        return -1;
+    }
+}
+/**
+ * One list for each sequence of types that a checker keeps (`Checker.typeLists`): references and
+ * instantiation caches hold the same type arguments in many places, mostly lists of one or two types,
+ * and share one list for them. A list must not change once it is in the table.
+ */
+export class TypeListTable {
+    heads = new Map();
+    lists = [];
+    /** The next list with the same hash, or -1, once two lists share one. */
+    nexts = undefined;
+    /**
+     * The list in the table with the types of `types`, in order, or `types` itself, which joins the
+     * table. `hash` is `typeListHash(types, undefined, 0)`.
+     */
+    intern(hash, types) {
+        if (types.length === 0)
+            return types;
+        const head = this.heads.get(hash);
+        const nexts = this.nexts;
+        if (head !== undefined)
+            for (let entry = head; entry >= 0; entry = nexts !== undefined ? nexts[entry] : -1) {
+                const list = this.lists[entry];
+                if (sameTypeListParts(list, types))
+                    return list;
+            }
+        const entry = this.lists.length;
+        this.lists.push(types);
+        if (nexts !== undefined)
+            nexts.push(-1);
+        if (head === undefined) {
+            this.heads.set(hash, entry);
+            return types;
+        }
+        // A second list with this hash: chain it after the first.
+        let chain = nexts;
+        if (chain === undefined) {
+            chain = [];
+            for (let i = 0; i <= entry; i++)
+                chain.push(-1);
+            this.nexts = chain;
+        }
+        chain[entry] = chain[head];
+        chain[head] = entry;
+        return types;
     }
 }
 /**
@@ -133,7 +235,7 @@ export class TypeExtra {
     origin;
     keyPropertyName;
     constituentMap;
-    constituentSet;
+    constituentIds;
     membershipTests;
     // IntersectionType
     uniqueLiteralFilledInstantiation;
@@ -146,7 +248,7 @@ export class TypeExtra {
         this.origin = undefined;
         this.keyPropertyName = '';
         this.constituentMap = undefined;
-        this.constituentSet = undefined;
+        this.constituentIds = undefined;
         this.membershipTests = 0;
         this.uniqueLiteralFilledInstantiation = undefined;
     }
@@ -635,19 +737,43 @@ export class EvolvingArrayType extends ObjectType {
         this.finalArrayType = undefined;
     }
 }
-export class UnionOrIntersectionType extends StructuredType {
+/**
+ * A union or intersection. Few have their members resolved or their properties cached, so those
+ * live in `membersOf` (`UnionOrIntersectionMembers`), which is created when they are first written.
+ */
+export class UnionOrIntersectionType extends Type {
     types;
-    propertyCache;
-    propertyCacheWithoutFunctionPropertyAugment;
-    resolvedProperties;
+    membersOf;
     constructor(flags, objectFlags, id, types) {
         super(flags, objectFlags, id, undefined);
         this.types = types;
+        this.membersOf = undefined;
+    }
+}
+/**
+ * The resolved members of a union or intersection (`membersHolder`) and the caches of its
+ * properties, created on first use.
+ */
+export class UnionOrIntersectionMembers extends StructuredType {
+    propertyCache;
+    propertyCacheWithoutFunctionPropertyAugment;
+    resolvedProperties;
+    constructor(flags, id) {
+        super(flags, 0 /* ObjectFlags.None */, id, undefined);
         this.propertyCache = undefined;
         this.propertyCacheWithoutFunctionPropertyAugment = undefined;
         this.resolvedProperties = undefined;
     }
 }
+/** The members holder of a union or intersection, created if it has none yet. */
+export function unionOrIntersectionMembers(t) {
+    let members = t.membersOf;
+    if (members === undefined) {
+        members = new UnionOrIntersectionMembers(t.flags, t.id);
+        t.membersOf = members;
+    }
+    return members;
+}
 /** A union; all of its own fields are rarely set and live in `extra`. */
 export class UnionType extends UnionOrIntersectionType {
     constructor(objectFlags, id, types) {
@@ -695,14 +821,18 @@ export class UnionType extends UnionOrIntersectionType {
         if (map !== undefined || this.extra !== undefined)
             typeExtra(this).constituentMap = map;
     }
-    /** The constituents of a large union, for membership tests; created on the second test. */
-    get constituentSet() {
+    /**
+     * A hash table of the ids of a large union's constituents, for membership tests; created on the
+     * second test (`constituentTable`). About eight bytes a constituent, where a set of them took
+     * about five times that.
+     */
+    get constituentIds() {
         const extra = this.extra;
-        return extra !== undefined ? extra.constituentSet : undefined;
+        return extra !== undefined ? extra.constituentIds : undefined;
     }
-    set constituentSet(set) {
-        if (set !== undefined || this.extra !== undefined)
-            typeExtra(this).constituentSet = set;
+    set constituentIds(ids) {
+        if (ids !== undefined || this.extra !== undefined)
+            typeExtra(this).constituentIds = ids;
     }
     get membershipTests() {
         const extra = this.extra;
@@ -1111,6 +1241,40 @@ export class ArrayTypeMapper extends TypeMapper {
     mapsThisOnly() {
         return this.sources.length === 1 && isThisTypeParameter(this.sources[0]);
     }
+    /** The number of targets, one per source. */
+    targetCount() {
+        return this.targets.length;
+    }
+    /** The target of the source at `index`. */
+    targetAt(index) {
+        return this.targets[index];
+    }
+}
+/**
+ * The mapper of a type reference's members: its type arguments, then the reference itself for the
+ * last source, the class or interface's `this` type. `targets` holds the type arguments only, so the
+ * reference's own list serves without a copy that adds the reference.
+ */
+export class ThisArgumentTypeMapper extends ArrayTypeMapper {
+    thisTarget;
+    constructor(sources, typeArguments, thisTarget) {
+        super(sources, typeArguments);
+        this.thisTarget = thisTarget;
+    }
+    map(type) {
+        const sources = this.sources;
+        const last = sources.length - 1;
+        for (let i = 0; i < last; i++)
+            if (type === sources[i])
+                return this.targets[i];
+        return type === sources[last] ? this.thisTarget : type;
+    }
+    targetCount() {
+        return this.targets.length + 1;
+    }
+    targetAt(index) {
+        return index < this.targets.length ? this.targets[index] : this.thisTarget;
+    }
 }
 /**
  * The number of sources from which a mapper looks types up in an index. A tuple reference with thousands of
@@ -1178,6 +1342,19 @@ export function newTypeMapper(sources, targets) {
         ? new IndexedArrayTypeMapper(sources, targets)
         : new ArrayTypeMapper(sources, targets);
 }
+/** `newTypeMapper(sources, [...typeArguments, thisTarget])`, without building that list where it can. */
+export function newThisArgumentTypeMapper(sources, typeArguments, thisTarget) {
+    if (sources.length === 1)
+        return new SimpleTypeMapper(sources[0], thisTarget);
+    if (sources.length >= indexedTypeMapperThreshold) {
+        const targets = [];
+        for (const t of typeArguments)
+            targets.push(t);
+        targets.push(thisTarget);
+        return new IndexedArrayTypeMapper(sources, targets);
+    }
+    return new ThisArgumentTypeMapper(sources, typeArguments, thisTarget);
+}
 export function mergeTypeMappers(m1, m2) {
     return m1 !== undefined ? new MergedTypeMapper(m1, m2) : m2;
 }

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

@@ -1,7 +1,7 @@
 import { type Node, type SourceFile } from './ast.js';
 import { type Checker } from './checker.js';
-import { type Symbol } from './symbol.js';
 import type { Type } from './checker-types.js';
+import { type Symbol } from './symbol.js';
 /** Whether `node` is only written, as the target of `=` or of a for-in/of initializer. */
 export declare function isWriteOnlyAccess(node: Node): boolean;
 /** Whether `node` is written, possibly also read. */

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

@@ -7,7 +7,6 @@ import { isAmbientModule, isAssignmentOperator, isGlobalScopeAugmentation, isTyp
 import { getCombinedNodeFlags, getModifierFlags, getRootDeclaration, getSourceFileOfNode, hasSyntacticModifier, isExternalOrCommonJSModule, isParameterPropertyDeclaration, } from './binder-utilities.js';
 import { createDiagnosticForNode } from './checker.js';
 import { Diagnostic } from './diagnostics.js';
-import { getSymbolId } from './symbol.js';
 import { getMergedSymbol, getSymbolOfDeclaration } from './checker-symbols.js';
 import { getResolvedSymbol } from './checker-expressions.js';
 import { skipTrivia } from './scanner.js';
@@ -17,6 +16,7 @@ import { symbolToString } from './type-printer.js';
 import { getLiteralTypeFromPropertyName } from './checker-type-operators.js';
 import { getPropertyOfType } from './checker-members.js';
 import { getPropertyNameFromType, isTypeUsableAsPropertyName } from './checker-utilities.js';
+import { getDeclarations, getSymbolId } from './symbol.js';
 // ---- References
 /** Whether `node` is only written, as the target of `=` or of a for-in/of initializer. */
 export function isWriteOnlyAccess(node) {
@@ -342,7 +342,7 @@ function checkUnusedLocalsAndParameters(c, node) {
             local.exportSymbol !== undefined ||
             (local.flags & 134217728 /* SymbolFlags.ModuleExports */) !== 0)
             continue;
-        for (const declaration of local.declarations) {
+        for (const declaration of getDeclarations(local)) {
             switch (declaration.kind) {
                 case 261 /* SyntaxKind.VariableDeclaration */:
                 case 170 /* SyntaxKind.Parameter */:
@@ -513,7 +513,7 @@ function isUnreferencedTypeParameter(c, typeParameter) {
     return ((referenceKinds & 262144 /* SymbolFlags.TypeParameter */) === 0 && !isIdentifierThatStartsWithUnderscore(getName(typeParameter)));
 }
 function allDeclarationsInSameSourceFile(symbol) {
-    const declarations = symbol.declarations;
+    const declarations = getDeclarations(symbol);
     if (declarations.length <= 1)
         return true;
     const file = getSourceFileOfNode(declarations[0]);

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

@@ -1,11 +1,12 @@
 import type { DeferredCollisionCheck } from './checker-generated-code.js';
 import type { EmitHelperFileLinks } from './checker-emit-helpers.js';
 import type { Node, PatternAmbientModule, SourceFile } from './ast.js';
-import { IntLinkTable, LinkTable, SparseLinkTable } from './link-tables.js';
+import { CompactSymbolLinkTable, IntLinkTable, LinkTable, SparseLinkTable } from './link-tables.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, type ConditionalType, type InterfaceType, type TypeChecking } from './checker-types.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 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 { TypeNodeVisitor } from './checker-source-file.js';
@@ -15,11 +16,11 @@ import type { FlowNode, FlowReduceLabel } from './flow.js';
 import { JsxState } from './checker-jsx.js';
 import type { DeferredIterationError, IterationTypes } from './checker-iteration.js';
 import type { SpreadIndices } from './checker-contextual.js';
-import type { SlotSiblingProperties } from './checker-symbol-types.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';
 /** What the checker needs from a program. */
 export declare abstract class CheckerHost {
     abstract getCompilerOptions(): CompilerOptions;
@@ -77,6 +78,21 @@ declare class DiagnosticCollection {
 }
 /** Maximum depth of nested `typeToString` calls before diagnostics are discarded. */
 export declare const maxSerializationLevel = 2;
+/**
+ * File positions per symbol id in `ExternalModuleContainerIndex.keys`. Symbol ids are int32, so the
+ * keys stay exact.
+ */
+export declare const fileIndexScale: number;
+/** The modules that export each symbol, built once from every module's exports. */
+export declare class ExternalModuleContainerIndex {
+    complete: boolean;
+    /**
+     * One key per symbol and module that exports it, ascending: the id of the symbol the export
+     * resolves to times `fileIndexScale`, plus the module's file position in `Checker.files`. The
+     * keys of one symbol are contiguous and in program order.
+     */
+    keys: number[];
+}
 /** The checker's caches for symbol accessibility. */
 export declare class SymbolAccessibilityCaches {
     /** Accessible chains by symbol id, then by `chainCacheKey`. */
@@ -87,6 +103,8 @@ export declare class SymbolAccessibilityCaches {
     readonly containersByFile: Map<number, Map<number, Symbol[]>>;
     /** All modules that export a symbol, by symbol id. */
     readonly containers: Map<number, Symbol[]>;
+    /** The modules each symbol is exported from, built on the first search of all modules. */
+    externalModuleContainers: ExternalModuleContainerIndex | undefined;
     /** The name tables of named class expressions, by node id. */
     readonly classExpressionNames: Map<number, SymbolTable>;
     /** Computed declaration visibility by node id (see isDeclarationVisible), 0 if not computed. */
@@ -135,6 +153,15 @@ export declare class Checker implements TypeChecking {
     currentNode: Node | undefined;
     readonly diagnostics: DiagnosticCollection;
     readonly suggestionDiagnostics: DiagnosticCollection;
+    /** Diagnostics and suggestions reported so far, whether kept or not (`resolveExternalModule`'s cache). */
+    reports: number;
+    /** `resolveExternalModule` results that reported nothing, by module specifier (checker-modules.ts). */
+    readonly moduleResolutions: Map<Node, ModuleResolution>;
+    /**
+     * Whether ambient modules and module augmentations are merged. Merging can give a module a new
+     * merged symbol, so `resolveExternalModule` keeps results only from then on.
+     */
+    modulesMerged: boolean;
     /** Module specifiers of `import("…")` types, by module symbol id, importing file path and resolution mode. */
     readonly moduleSpecifiers: Map<string, string>;
     /** Specifier generation for hosts without a program. */
@@ -145,6 +172,11 @@ export declare class Checker implements TypeChecking {
     readonly sideHolders: LinkTable<Type>;
     /** The same for signatures with side state (`signatureSideOf`), by signature id. */
     readonly signatureSideHolders: LinkTable<Signature>;
+    /**
+     * The indexes of long property lists that `propertiesRelatedTo` walks; before a list is indexed, its uses
+     * so far; null where a list repeats a name.
+     */
+    readonly propertyListIndexes: Map<Symbol[], number | PropertyListIndex | null>;
     /** The type of a value symbol. */
     readonly symbolTypes: LinkTable<Type>;
     /** For instantiated and synthetic symbols, the symbol they come from. */
@@ -165,7 +197,7 @@ export declare class Checker implements TypeChecking {
     /** Bits of SymbolFlags for the meanings in which a symbol was referenced. */
     readonly symbolReferenceKinds: IntLinkTable;
     /** The resolved symbol of an identifier, entity name or call. */
-    readonly resolvedSymbols: SparseLinkTable<Symbol>;
+    readonly resolvedSymbols: CompactSymbolLinkTable;
     /** The resolved type of a type node or expression. */
     readonly resolvedTypes: SparseLinkTable<Type>;
     /** The resolved signature of a call-like node or a signature declaration. */
@@ -201,10 +233,6 @@ export declare class Checker implements TypeChecking {
     readonly unresolvedSymbols: Map<string, Symbol>;
     /** Widening's optional `undefined` properties by the id of the property each is created from. */
     readonly undefinedProperties: Map<number, Symbol>;
-    /** By file and name, the property that widening's optional `undefined` properties are created from. */
-    readonly firstSiblingProperties: Map<SourceFile, Map<string, Node>>;
-    /** By tsgo checker, the first sibling properties of its files (firstSiblingProperty). */
-    readonly slotSiblingProperties: Map<number, SlotSiblingProperties>;
     readonly stringLiteralTypes: Map<string, LiteralType>;
     readonly numberLiteralTypes: Map<number, LiteralType>;
     readonly bigintLiteralTypes: Map<string, LiteralType>;
@@ -222,6 +250,8 @@ export declare class Checker implements TypeChecking {
     readonly templateLiteralTypes: Map<string, Type>;
     /** Instantiations of template literal types: the instantiated types, tagged with the template's id. */
     readonly templateLiteralInstantiations: TypeListCache<Type>;
+    /** The type argument lists that references and instantiations keep, one of each (`TypeListTable`). */
+    readonly typeLists: TypeListTable;
     readonly stringMappingTypes: Map<string, Type>;
     readonly substitutionTypes: Map<string, Type>;
     readonly subtypeReductionCache: TypeListCache<Type[]>;
@@ -347,6 +377,13 @@ export declare class Checker implements TypeChecking {
      */
     readonly freeMapperCaches: Map<number, Type>[];
     freeMapperCacheCount: number;
+    /** 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
+     * to instantiate (`getObjectTypeInstantiation`).
+     */
+    readonly withoutOuterTypeParameters: IntLinkTable;
     conditionalConstraintDepth: number;
     readonly suggestionResolver: SuggestionNameResolver;
     readonly awaitedTypeStack: number[];

package/dist/api/compiler/checker.js

@@ -1,10 +1,10 @@
 import { sideOf } from './side-state.js';
-import { IntLinkTable, LinkTable, SparseLinkTable } from './link-tables.js';
+import { CompactSymbolLinkTable, IntLinkTable, LinkTable, SparseLinkTable } from './link-tables.js';
 import { getErrorRangeForNode, getSourceFileOfNode } from './binder-utilities.js';
 import { Diagnostic, compareDiagnostics } 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, } from './checker-types.js';
+import { IndexInfo, IntrinsicType, LiteralType, NodeLinks, Signature, SymbolLinks, TypeParameter, TypePredicate, emptyTypes, TypeListCache, TypeListTable, } from './checker-types.js';
 import { getBaseTypes } from './checker-declared-types.js';
 import { getFalseTypeFromConditionalType, getTrueTypeFromConditionalType } from './checker-type-operators.js';
 import { createArrayType, createTypeFromGenericGlobalType, getBigIntLiteralType, getNumberLiteralType, getStringLiteralType, getTemplateLiteralType, getUnionType, newAnonymousType, newObjectType, } from './checker-type-factory.js';
@@ -154,6 +154,21 @@ function stableSort(list) {
 }
 /** Maximum depth of nested `typeToString` calls before diagnostics are discarded. */
 export const maxSerializationLevel = 2;
+/**
+ * File positions per symbol id in `ExternalModuleContainerIndex.keys`. Symbol ids are int32, so the
+ * keys stay exact.
+ */
+export const fileIndexScale = 2 ** 21;
+/** The modules that export each symbol, built once from every module's exports. */
+export class ExternalModuleContainerIndex {
+    complete = false;
+    /**
+     * One key per symbol and module that exports it, ascending: the id of the symbol the export
+     * resolves to times `fileIndexScale`, plus the module's file position in `Checker.files`. The
+     * keys of one symbol are contiguous and in program order.
+     */
+    keys = [];
+}
 /** The checker's caches for symbol accessibility. */
 export class SymbolAccessibilityCaches {
     /** Accessible chains by symbol id, then by `chainCacheKey`. */
@@ -164,6 +179,8 @@ export class SymbolAccessibilityCaches {
     containersByFile = new Map();
     /** All modules that export a symbol, by symbol id. */
     containers = new Map();
+    /** The modules each symbol is exported from, built on the first search of all modules. */
+    externalModuleContainers = undefined;
     /** The name tables of named class expressions, by node id. */
     classExpressionNames = new Map();
     /** Computed declaration visibility by node id (see isDeclarationVisible), 0 if not computed. */
@@ -213,6 +230,15 @@ export class Checker {
     currentNode = undefined;
     diagnostics = new DiagnosticCollection();
     suggestionDiagnostics = new DiagnosticCollection();
+    /** Diagnostics and suggestions reported so far, whether kept or not (`resolveExternalModule`'s cache). */
+    reports = 0;
+    /** `resolveExternalModule` results that reported nothing, by module specifier (checker-modules.ts). */
+    moduleResolutions = new Map();
+    /**
+     * Whether ambient modules and module augmentations are merged. Merging can give a module a new
+     * merged symbol, so `resolveExternalModule` keeps results only from then on.
+     */
+    modulesMerged = false;
     /** Module specifiers of `import("…")` types, by module symbol id, importing file path and resolution mode. */
     moduleSpecifiers = new Map();
     /** Specifier generation for hosts without a program. */
@@ -226,6 +252,11 @@ export class Checker {
     sideHolders = new LinkTable();
     /** The same for signatures with side state (`signatureSideOf`), by signature id. */
     signatureSideHolders = new LinkTable();
+    /**
+     * The indexes of long property lists that `propertiesRelatedTo` walks; before a list is indexed, its uses
+     * so far; null where a list repeats a name.
+     */
+    propertyListIndexes = new Map();
     /** The type of a value symbol. */
     symbolTypes = new LinkTable();
     /** For instantiated and synthetic symbols, the symbol they come from. */
@@ -246,7 +277,7 @@ export class Checker {
     /** Bits of SymbolFlags for the meanings in which a symbol was referenced. */
     symbolReferenceKinds = new IntLinkTable();
     /** The resolved symbol of an identifier, entity name or call. */
-    resolvedSymbols = new SparseLinkTable();
+    resolvedSymbols = new CompactSymbolLinkTable();
     /** The resolved type of a type node or expression. */
     resolvedTypes = new SparseLinkTable();
     /** The resolved signature of a call-like node or a signature declaration. */
@@ -283,10 +314,6 @@ export class Checker {
     unresolvedSymbols = new Map();
     /** Widening's optional `undefined` properties by the id of the property each is created from. */
     undefinedProperties = new Map();
-    /** By file and name, the property that widening's optional `undefined` properties are created from. */
-    firstSiblingProperties = new Map();
-    /** By tsgo checker, the first sibling properties of its files (firstSiblingProperty). */
-    slotSiblingProperties = new Map();
     // Interning tables.
     stringLiteralTypes = new Map();
     numberLiteralTypes = new Map();
@@ -305,6 +332,8 @@ export class Checker {
     templateLiteralTypes = new Map();
     /** Instantiations of template literal types: the instantiated types, tagged with the template's id. */
     templateLiteralInstantiations = new TypeListCache();
+    /** The type argument lists that references and instantiations keep, one of each (`TypeListTable`). */
+    typeLists = new TypeListTable();
     stringMappingTypes = new Map();
     substitutionTypes = new Map();
     subtypeReductionCache = new TypeListCache();
@@ -436,6 +465,13 @@ export class Checker {
      */
     freeMapperCaches = [];
     freeMapperCacheCount = 0;
+    /** 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
+     * to instantiate (`getObjectTypeInstantiation`).
+     */
+    withoutOuterTypeParameters = new IntLinkTable();
     conditionalConstraintDepth = 0;
     suggestionResolver;
     awaitedTypeStack = [];
@@ -718,6 +754,7 @@ export class Checker {
         this.diagnostics.startLog();
         this.suggestionDiagnostics.startLog();
         mergeAmbientModulesAndAugmentations(this);
+        this.modulesMerged = true;
         this.mergeDiagnostics.push(this.diagnostics.takeLog(), this.suggestionDiagnostics.takeLog());
     }
     // ---- Public API
@@ -808,11 +845,13 @@ export class Checker {
         return 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);
     }
     addSuggestion(diagnostic) {
+        this.reports++;
         this.suggestionDiagnostics.add(diagnostic);
     }
     /** Reports an error, or a suggestion when `isError` is false. */
@@ -858,8 +897,6 @@ export function disposeChecker(c) {
     c.symbolAccessibilityCaches = undefined;
     c.unresolvedSymbols.clear();
     c.undefinedProperties.clear();
-    c.firstSiblingProperties.clear();
-    c.slotSiblingProperties.clear();
     c.stringLiteralTypes.clear();
     c.numberLiteralTypes.clear();
     c.bigintLiteralTypes.clear();