tsc-ts 0.0.5 → 0.0.6

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,11 @@
 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 { 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,7 +15,6 @@ 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';
@@ -77,6 +76,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 +101,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. */
@@ -165,7 +181,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 +217,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 +234,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 +361,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. */
@@ -246,7 +263,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 +300,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 +318,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 +451,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 = [];
@@ -858,8 +880,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();

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

@@ -32,9 +32,8 @@ export declare function localizeMessage(locale: Locale, message: DiagnosticMessa
 export declare function formatMessage(text: string, args: readonly string[]): string;
 /**
  * Makes this thread compute the caches of files that do not have them yet in copies of its own: the
- * files may be published (immutable) and shared with other threads. Declaration files leave the
- * parser without them (`Parser.parseSourceFile`): they make up most of the text of a typical program,
- * and are rarely checked or pointed into by a diagnostic.
+ * files may be published (immutable) and shared with other threads. Files leave the parser without
+ * them (`Parser.parseSourceFile`): most files are never pointed into by a diagnostic.
  */
 export declare function useThreadTextCaches(): void;
 /** The text of a file diagnostics point into. */
@@ -51,11 +50,6 @@ export declare class DiagnosticFile {
      * thread's copy where the file may be shared (`useThreadTextCaches`).
      */
     computeCaches(): void;
-    /**
-     * Like `computeCaches`, from the text's UTF-16 code units `units[0, text.length)`, so the text
-     * itself is neither searched nor copied.
-     */
-    computeCachesFromUnits(units: Uint16Array): void;
     /** Start offsets of each line, split at CR, LF, CRLF, LS and PS. */
     getLineStarts(): readonly number[];
     private nonASCIIStarts;

package/dist/api/compiler/diagnostics.js

@@ -125,14 +125,14 @@ function toWellFormed(text) {
 /**
  * Where this thread computes the line starts and UTF-8 offsets of files that may be shared with other
  * threads (`useThreadTextCaches`): a copy of each such file, by file, that computes them in place.
- * Files leave the parser with line starts, except declaration files, and without UTF-8 offsets.
+ * Files leave the parser without line starts and UTF-8 offsets, except JSON files, which have line
+ * starts.
  */
 let threadCopies = undefined;
 /**
  * Makes this thread compute the caches of files that do not have them yet in copies of its own: the
- * files may be published (immutable) and shared with other threads. Declaration files leave the
- * parser without them (`Parser.parseSourceFile`): they make up most of the text of a typical program,
- * and are rarely checked or pointed into by a diagnostic.
+ * files may be published (immutable) and shared with other threads. Files leave the parser without
+ * them (`Parser.parseSourceFile`): most files are never pointed into by a diagnostic.
  */
 export function useThreadTextCaches() {
     if (threadCopies === undefined)
@@ -152,15 +152,6 @@ function threadCopyOf(file) {
     }
     return copy;
 }
-/** The position of the first code unit at or after `pos` that is a CR or below, or not ASCII; or `end`. */
-function skipPlainASCII(units, pos, end) {
-    for (let i = pos | 0; i < end; i = (i + 1) | 0) {
-        const c = units[i] | 0;
-        if (c <= 13 /* CharacterCodes.carriageReturn */ || c >= 0x80)
-            return i;
-    }
-    return end;
-}
 /** The text of a file diagnostics point into. */
 export class DiagnosticFile {
     fileName;
@@ -182,33 +173,6 @@ export class DiagnosticFile {
         if (this.lineStarts.length === 0)
             this.lineStarts = computeLineStarts(this.text);
     }
-    /**
-     * Like `computeCaches`, from the text's UTF-16 code units `units[0, text.length)`, so the text
-     * itself is neither searched nor copied.
-     */
-    computeCachesFromUnits(units) {
-        const text = this.text;
-        // ASCII texts are searched faster than walked.
-        if (this.lineStarts.length !== 0 || Buffer.byteLength(text, 'utf8') === text.length) {
-            this.computeCaches();
-            return;
-        }
-        const length = text.length | 0;
-        const lineStarts = [0];
-        // Visit only the code units that may break a line; `skipPlainASCII` runs over the rest without
-        // calls, so native builds keep its loop on registers. A CR followed by an LF leaves the line start
-        // to the LF.
-        for (let i = skipPlainASCII(units, 0, length); i < length; i = skipPlainASCII(units, (i + 1) | 0, length)) {
-            const ch = units[i] | 0;
-            if (ch === 10 /* CharacterCodes.lineFeed */ ||
-                (ch === 13 /* CharacterCodes.carriageReturn */ &&
-                    (i + 1 >= length || (units[(i + 1) | 0] | 0) !== 10 /* CharacterCodes.lineFeed */)) ||
-                ch === 8232 /* CharacterCodes.lineSeparator */ ||
-                ch === 8233 /* CharacterCodes.paragraphSeparator */)
-                lineStarts.push(i + 1);
-        }
-        this.lineStarts = lineStarts;
-    }
     /** Start offsets of each line, split at CR, LF, CRLF, LS and PS. */
     getLineStarts() {
         if (this.lineStarts.length === 0) {