tsc-ts 0.0.5 → 0.0.7

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

@@ -1,7 +1,7 @@
 import { type Node } from './ast.js';
-import { type Symbol } from './symbol.js';
 import type { Checker, VarianceReporting } from './checker.js';
 import { IndexInfo, type ObjectType, Signature, type Type, TypeAlias, TypeMapper, TypeParameter } from './checker-types.js';
+import { type Symbol } from './symbol.js';
 /** Applies `m1`, then instantiates its result with `m2`, or applies `m2` when `m1` doesn't map. */
 export declare class CompositeTypeMapper extends TypeMapper {
     readonly c: Checker;

package/dist/api/compiler/instantiation.js

@@ -1,7 +1,6 @@
 // Instantiation: mappers that need the checker, and `instantiateType` for every kind of type.
 import { lazyObjectFlags, sideOf, sideOfIfAny } from './side-state.js';
 import { NodeVisitor, getBody, getInitializer, getParameters, getType, getTypeArguments as getTypeArgumentNodes, getTypeParameters as getTypeParameterNodes, } from './ast.js';
-import { getSymbolId } from './symbol.js';
 import { cachedTypeKey, IndexInfo, Signature, TypeAlias, TypeMapper, emptyTypes, newTypeMapper, SimpleTypeMapper, TypeListCache, } from './checker-types.js';
 import { createDeferredTypeReference, createNormalizedTypeReference, getIntersectionType, getIntersectionTypeEx, getPropagatingFlagsOfTypes, getTemplateLiteralType, getTypeArguments, getUnionTypeEx, newObjectType, aliasKey, typesOf, typeListHash, } from './checker-type-factory.js';
 import { getOuterTypeParameters } from './checker-declared-types.js';
@@ -10,6 +9,7 @@ import { getConditionalTypeInstantiation, getIndexType, getIndexedAccessTypeEx,
 import { getConstraintDeclaration } from './checker-declared-types.js';
 import { isTypeAssignableTo } from './relations.js';
 import { getFirstIdentifier } from './checker-symbols.js';
+import { copyDeclarations, declarationCount, getDeclarations, getSymbolId, } from './symbol.js';
 // ---- Mappers that need the checker
 /** Applies `m1`, then instantiates its result with `m2`, or applies `m2` when `m1` doesn't map. */
 export class CompositeTypeMapper extends TypeMapper {
@@ -88,8 +88,19 @@ export function instantiateType(c, type, mapper) {
 export function instantiateTypeWithAlias(c, type, mapper, alias) {
     if (mapper === undefined)
         return type;
-    // Aliases with type arguments may be copied with new arguments even when the type itself has no type variables.
-    if (!couldContainTypeVariables(c, type) && !aliasCouldContainTypeVariables(c, type))
+    // `couldContainTypeVariables`, answered here when the type's own flags decide it. Aliases with type
+    // arguments may be copied with new arguments even when the type itself has no type variables.
+    let could;
+    if ((type.flags & 536346624 /* TypeFlags.StructuredOrInstantiable */) === 0)
+        could = false;
+    else {
+        const objectFlags = type.objectFlags;
+        could =
+            (objectFlags & 524288 /* ObjectFlags.CouldContainTypeVariablesComputed */) !== 0
+                ? (objectFlags & 1048576 /* ObjectFlags.CouldContainTypeVariables */) !== 0
+                : couldContainTypeVariables(c, type);
+    }
+    if (!could && (type.alias === undefined || !aliasCouldContainTypeVariables(c, type)))
         return type;
     if (c.instantiationDepth === 100 || c.instantiationCount >= 5000000) {
         // Probably infinitely expanding generic types; stop with the error type.
@@ -218,7 +229,7 @@ export function couldContainTypeVariables(c, type) {
                             32 /* SymbolFlags.Class */ |
                             2048 /* SymbolFlags.TypeLiteral */ |
                             4096 /* SymbolFlags.ObjectLiteral */)) !==
-                        0 && type.symbol.declarations.length !== 0;
+                        0 && declarationCount(type.symbol) !== 0;
             }
             if (!result)
                 result =
@@ -249,7 +260,7 @@ function isNonGenericTopLevelType(type) {
     if (alias === undefined || alias.typeArguments.length !== 0)
         return false;
     let declaration;
-    for (const d of alias.symbol.declarations)
+    for (const d of getDeclarations(alias.symbol))
         if (d.kind === 266 /* SyntaxKind.TypeAliasDeclaration */ || d.kind === 345 /* SyntaxKind.JSTypeAliasDeclaration */) {
             declaration = d;
             break;
@@ -346,13 +357,15 @@ function instantiateTypeWorker(c, type, mapper, alias) {
 }
 /** Instantiates anonymous types, deferred references, instantiation expressions and mapped types. */
 function getObjectTypeInstantiation(c, type, mapper, alias) {
+    if ((type.objectFlags & 4 /* ObjectFlags.Reference */) === 0 && c.withoutOuterTypeParameters.get(type.id) !== 0)
+        return type;
     let declaration;
     if ((type.objectFlags & 4 /* ObjectFlags.Reference */) !== 0)
         declaration = type.node;
     else if ((type.objectFlags & 16777216 /* ObjectFlags.InstantiationExpressionType */) !== 0)
         declaration = type.node;
     else
-        declaration = type.symbol.declarations[0];
+        declaration = type.symbol.declaration;
     const links = c.nodeLinks(declaration);
     let target;
     if ((type.objectFlags & 4 /* ObjectFlags.Reference */) !== 0)
@@ -376,7 +389,7 @@ function getObjectTypeInstantiation(c, type, mapper, alias) {
             else if ((target.symbol.flags & (8192 /* SymbolFlags.Method */ | 2048 /* SymbolFlags.TypeLiteral */)) !== 0) {
                 const referenced = [];
                 for (const tp of typeParameters) {
-                    for (const d of type.symbol.declarations) {
+                    for (const d of getDeclarations(type.symbol)) {
                         if (isTypeParameterPossiblyReferenced(c, tp, d)) {
                             referenced.push(tp);
                             break;
@@ -388,16 +401,27 @@ function getObjectTypeInstantiation(c, type, mapper, alias) {
         }
         links.outerTypeParameters = typeParameters;
     }
-    if (typeParameters.length === 0)
+    if (typeParameters.length === 0) {
+        if ((type.objectFlags & 4 /* ObjectFlags.Reference */) === 0)
+            c.withoutOuterTypeParameters.set(type.id, 1);
         return type;
-    const combinedMapper = combineTypeMappers(c, type.mapper, mapper);
-    const typeArguments = [];
-    for (const tp of typeParameters)
-        typeArguments.push(combinedMapper.map(tp));
+    }
+    // The type arguments, mapped as `combineTypeMappers(c, type.mapper, mapper)` maps them, into a
+    // list of the checker's that is copied only when the instantiation is new.
+    const typeMapper = type.mapper;
+    const mapped = c.freeTypeLists.pop() ?? [];
+    for (const tp of typeParameters) {
+        if (typeMapper === undefined)
+            mapped.push(mapper.map(tp));
+        else {
+            const t1 = typeMapper.map(tp);
+            mapped.push(t1 !== tp ? instantiateType(c, t1, mapper) : mapper.map(tp));
+        }
+    }
     const newAlias = alias ?? instantiateTypeAlias(c, type.alias, mapper);
     const singleSignature = (type.objectFlags & 33554432 /* ObjectFlags.SingleSignatureType */) !== 0;
     const tag = singleSignature ? 1 : 0;
-    const hash = typeListHash(typeArguments, newAlias, tag);
+    const hash = typeListHash(mapped, newAlias, tag);
     const generic = sideOf(c, target);
     let instantiations = generic.instantiations;
     if (instantiations === undefined) {
@@ -405,33 +429,41 @@ function getObjectTypeInstantiation(c, type, mapper, alias) {
         instantiations.set(typeListHash(typeParameters, target.alias, 0), typeParameters, target.alias, 0, target);
         generic.instantiations = instantiations;
     }
-    let result = instantiations.get(hash, typeArguments, newAlias, tag);
-    if (result === undefined) {
-        let newMapper = newTypeMapper(typeParameters, typeArguments);
-        if ((target.objectFlags & 33554432 /* ObjectFlags.SingleSignatureType */) !== 0)
-            newMapper = combineTypeMappers(c, newMapper, mapper);
-        if ((target.objectFlags & 4 /* ObjectFlags.Reference */) !== 0)
-            result = createDeferredTypeReference(c, type.target, type.node, newMapper, newAlias);
-        else if ((target.objectFlags & 32 /* ObjectFlags.Mapped */) !== 0)
-            result = instantiateMappedType(c, target, newMapper, newAlias);
-        else
-            result = instantiateAnonymousType(c, target, newMapper, newAlias);
-        instantiations.set(hash, typeArguments, newAlias, tag, result);
-        if ((result.flags & 403963917 /* TypeFlags.ObjectFlagsType */) !== 0 &&
-            (lazyObjectFlags(c, result) & 524288 /* ObjectFlags.CouldContainTypeVariablesComputed */) === 0) {
-            // Type variable containment follows from the type arguments.
-            let couldContain = false;
-            for (const t of typeArguments)
-                if (couldContainTypeVariables(c, t)) {
-                    couldContain = true;
-                    break;
-                }
-            if ((result.objectFlags & (32 /* ObjectFlags.Mapped */ | 16 /* ObjectFlags.Anonymous */ | 4 /* ObjectFlags.Reference */)) !== 0)
-                sideOf(c, result).objectFlags |=
-                    524288 /* ObjectFlags.CouldContainTypeVariablesComputed */ | (couldContain ? 1048576 /* ObjectFlags.CouldContainTypeVariables */ : 0);
-            else if (!couldContain)
-                sideOf(c, result).objectFlags |= 524288 /* ObjectFlags.CouldContainTypeVariablesComputed */;
-        }
+    const cached = instantiations.get(hash, mapped, newAlias, tag);
+    if (cached !== undefined) {
+        mapped.length = 0;
+        c.freeTypeLists.push(mapped);
+        return cached;
+    }
+    // The cache and the instantiation's mapper keep the type arguments.
+    const typeArguments = c.typeLists.intern(typeListHash(mapped, undefined, 0), mapped.slice());
+    mapped.length = 0;
+    c.freeTypeLists.push(mapped);
+    let result;
+    let newMapper = newTypeMapper(typeParameters, typeArguments);
+    if ((target.objectFlags & 33554432 /* ObjectFlags.SingleSignatureType */) !== 0)
+        newMapper = combineTypeMappers(c, newMapper, mapper);
+    if ((target.objectFlags & 4 /* ObjectFlags.Reference */) !== 0)
+        result = createDeferredTypeReference(c, type.target, type.node, newMapper, newAlias);
+    else if ((target.objectFlags & 32 /* ObjectFlags.Mapped */) !== 0)
+        result = instantiateMappedType(c, target, newMapper, newAlias);
+    else
+        result = instantiateAnonymousType(c, target, newMapper, newAlias);
+    instantiations.set(hash, typeArguments, newAlias, tag, result);
+    if ((result.flags & 403963917 /* TypeFlags.ObjectFlagsType */) !== 0 &&
+        (lazyObjectFlags(c, result) & 524288 /* ObjectFlags.CouldContainTypeVariablesComputed */) === 0) {
+        // Type variable containment follows from the type arguments.
+        let couldContain = false;
+        for (const t of typeArguments)
+            if (couldContainTypeVariables(c, t)) {
+                couldContain = true;
+                break;
+            }
+        if ((result.objectFlags & (32 /* ObjectFlags.Mapped */ | 16 /* ObjectFlags.Anonymous */ | 4 /* ObjectFlags.Reference */)) !== 0)
+            sideOf(c, result).objectFlags |=
+                524288 /* ObjectFlags.CouldContainTypeVariablesComputed */ | (couldContain ? 1048576 /* ObjectFlags.CouldContainTypeVariables */ : 0);
+        else if (!couldContain)
+            sideOf(c, result).objectFlags |= 524288 /* ObjectFlags.CouldContainTypeVariablesComputed */;
     }
     return result;
 }
@@ -464,14 +496,14 @@ class ReferenceFinder extends NodeVisitor {
                 if (firstIdentifier.kind !== 109 /* SyntaxKind.ThisKeyword */ &&
                     !(firstIdentifier.kind === 79 /* SyntaxKind.Identifier */ && firstIdentifier.text === 'this')) {
                     const symbol = getResolvedSymbolOfIdentifier(this.c, firstIdentifier);
-                    const tpDeclaration = tp.symbol.declarations[0];
+                    const tpDeclaration = tp.symbol.declaration;
                     let scope;
                     if (tpDeclaration.kind === 169 /* SyntaxKind.TypeParameter */)
                         scope = tpDeclaration.parent;
                     else if (tp.isThisType)
                         scope = tpDeclaration;
                     if (scope !== undefined) {
-                        for (const d of symbol.declarations)
+                        for (const d of getDeclarations(symbol))
                             if (isNodeDescendantOf(d, scope))
                                 return true;
                         const args = getTypeArgumentNodes(node);
@@ -521,10 +553,10 @@ export function isNodeDescendantOf(node, ancestor) {
  */
 export function isTypeParameterPossiblyReferenced(c, tp, node) {
     const typeParameter = tp;
-    if (tp.symbol === undefined || tp.symbol.declarations.length !== 1)
+    if (tp.symbol === undefined || declarationCount(tp.symbol) !== 1)
         return true;
     const finder = new ReferenceFinder(c, typeParameter);
-    const container = tp.symbol.declarations[0].parent;
+    const container = tp.symbol.declaration.parent;
     for (let n = node; n !== container; n = n.parent) {
         if (n === undefined || n.kind === 242 /* SyntaxKind.Block */)
             return true;
@@ -562,9 +594,13 @@ export function cloneTypeParameter(c, tp) {
     return result;
 }
 export function instantiateTypeAlias(c, alias, mapper) {
-    return alias === undefined
-        ? undefined
-        : new TypeAlias(alias.symbol, instantiateTypes(c, alias.typeArguments, mapper));
+    if (alias === undefined)
+        return undefined;
+    const typeArguments = instantiateTypes(c, alias.typeArguments, mapper);
+    // The alias's type keeps its type arguments.
+    return new TypeAlias(alias.symbol, typeArguments === alias.typeArguments
+        ? typeArguments
+        : c.typeLists.intern(typeListHash(typeArguments, undefined, 0), typeArguments));
 }
 /** Instantiates each type; returns `types` itself when nothing changed. */
 export function instantiateTypes(c, types, mapper) {
@@ -688,7 +724,7 @@ export function newInstantiatedSymbol(c, symbol, mapper) {
         1 /* CheckFlags.Instantiated */ |
             (symbol.checkFlags &
                 (8 /* CheckFlags.Readonly */ | 4096 /* CheckFlags.Late */ | 16384 /* CheckFlags.OptionalParameter */ | 32768 /* CheckFlags.RestParameter */));
-    result.declarations = symbol.declarations;
+    copyDeclarations(result, symbol);
     result.parent = symbol.parent;
     result.valueDeclaration = symbol.valueDeclaration;
     const id = getSymbolId(result);
@@ -699,9 +735,9 @@ export function newInstantiatedSymbol(c, symbol, mapper) {
 }
 /** Conservatively, whether a parameter or member's type can't reference `this`. */
 export function isThisless(symbol) {
-    if (symbol.declarations.length !== 1)
+    if (declarationCount(symbol) !== 1)
         return false;
-    const declaration = symbol.declarations[0];
+    const declaration = symbol.declaration;
     switch (declaration.kind) {
         case 170 /* SyntaxKind.Parameter */:
         case 173 /* SyntaxKind.PropertyDeclaration */:

package/dist/api/compiler/link-tables.d.ts

@@ -1,3 +1,4 @@
+import type { Symbol } from './symbol.js';
 /** Links are stored in pages of 256 ids. */
 export declare const enum LinkPaging {
     Bits = 8,
@@ -34,3 +35,71 @@ export declare class SparseLinkTable<T> {
     set(id: number, value: T | undefined): void;
     clear(): void;
 }
+/**
+ * Values by id for ids in a few clusters, as one file's emit uses them: the file's nodes and the
+ * nodes the emit synthesizes, far above them. Pages of `LinkPaging.Size` ids are found through a
+ * map from the page index, so the ids between clusters cost nothing, and the page of the last
+ * lookup is kept, since lookups come in runs of nearby ids.
+ */
+export declare class ClusteredLinkTable<T> {
+    private readonly pages;
+    private lastIndex;
+    private lastPage;
+    get(id: number): T | undefined;
+    set(id: number, value: T | undefined): void;
+    private pageOf;
+}
+/** Int32 values by id, zero where none is stored, for ids in a few clusters (`ClusteredLinkTable`). */
+export declare class ClusteredIntLinkTable {
+    private readonly pages;
+    private lastIndex;
+    private lastPage;
+    get(id: number): number;
+    set(id: number, value: number): void;
+    private pageOf;
+}
+/**
+ * A page of a `CompactSymbolLinkTable`: one bit per id of the page in eight 32-id words, the number
+ * of symbols stored before each word, and the symbols in id order. The words are fields, so a
+ * lookup reads one object before the symbols. The class isn't generic, so natively the words are
+ * 32-bit fields: every write stores an int32.
+ */
+declare class CompactLinkPage {
+    readonly values: Symbol[];
+    private w0;
+    private w1;
+    private w2;
+    private w3;
+    private w4;
+    private w5;
+    private w6;
+    private w7;
+    /** Byte `w & 3` of `before0` (words 1 to 3) or of `before1` (words 4 to 7): the values before word `w`. */
+    private before0;
+    private before1;
+    constructor();
+    /** The presence bits of ids `32 * word` to `32 * word + 31`. */
+    word(word: number): number;
+    setWord(word: number, bits: number): void;
+    /** The index in `values` of the value of `slot` (an id's low bits), or of where it goes. */
+    rank(slot: number, bits: number): number;
+    /** Adds `delta` to the counts of the words after `word`. */
+    shiftCounts(word: number, delta: number): void;
+}
+/**
+ * Symbols by node id, for ids a checker resolves in one in four to one in eight of the ids of the
+ * pages it touches, as it resolves the identifiers and names of the files it checks. Pages of
+ * `LinkPaging.Size` ids keep a presence bit per id and only the symbols stored, so a symbol costs
+ * about one array slot. A `LinkTable` page costs a slot for every id, and a `Map` entry also
+ * stores its key and a share of the hash buckets. At fewer values per page than that, the page's
+ * own allocations outweigh what it saves, and a `SparseLinkTable` costs less.
+ */
+export declare class CompactSymbolLinkTable {
+    readonly pages: (CompactLinkPage | undefined)[];
+    /** The number of symbols stored. */
+    size: number;
+    get(id: number): Symbol | undefined;
+    set(id: number, value: Symbol | undefined): void;
+    clear(): void;
+}
+export {};

package/dist/api/compiler/link-tables.js

@@ -81,3 +81,239 @@ export class SparseLinkTable {
         this.values.clear();
     }
 }
+/**
+ * Values by id for ids in a few clusters, as one file's emit uses them: the file's nodes and the
+ * nodes the emit synthesizes, far above them. Pages of `LinkPaging.Size` ids are found through a
+ * map from the page index, so the ids between clusters cost nothing, and the page of the last
+ * lookup is kept, since lookups come in runs of nearby ids.
+ */
+export class ClusteredLinkTable {
+    pages = new Map();
+    lastIndex = -1;
+    lastPage = undefined;
+    get(id) {
+        const page = this.pageOf(id >> 8 /* LinkPaging.Bits */);
+        return page !== undefined ? page[id & 255 /* LinkPaging.Mask */] : undefined;
+    }
+    set(id, value) {
+        const index = id >> 8 /* LinkPaging.Bits */;
+        const page = this.pageOf(index);
+        if (page !== undefined)
+            page[id & 255 /* LinkPaging.Mask */] = value;
+        else if (value !== undefined) {
+            const created = [];
+            for (let i = 0; i < 256 /* LinkPaging.Size */; i++)
+                created.push(undefined);
+            created[id & 255 /* LinkPaging.Mask */] = value;
+            this.pages.set(index, created);
+            this.lastPage = created;
+        }
+    }
+    pageOf(index) {
+        if (index !== this.lastIndex) {
+            this.lastIndex = index;
+            this.lastPage = this.pages.get(index);
+        }
+        return this.lastPage;
+    }
+}
+/** Int32 values by id, zero where none is stored, for ids in a few clusters (`ClusteredLinkTable`). */
+export class ClusteredIntLinkTable {
+    pages = new Map();
+    lastIndex = -1;
+    lastPage = undefined;
+    get(id) {
+        const page = this.pageOf(id >> 8 /* LinkPaging.Bits */);
+        return page !== undefined ? page[id & 255 /* LinkPaging.Mask */] : 0;
+    }
+    set(id, value) {
+        const index = id >> 8 /* LinkPaging.Bits */;
+        const page = this.pageOf(index);
+        if (page !== undefined)
+            page[id & 255 /* LinkPaging.Mask */] = value;
+        else if (value !== 0) {
+            const created = new Int32Array(256 /* LinkPaging.Size */);
+            created[id & 255 /* LinkPaging.Mask */] = value;
+            this.pages.set(index, created);
+            this.lastPage = created;
+        }
+    }
+    pageOf(index) {
+        if (index !== this.lastIndex) {
+            this.lastIndex = index;
+            this.lastPage = this.pages.get(index);
+        }
+        return this.lastPage;
+    }
+}
+/** The number of set bits of a 32-bit value. */
+function bitCount(x) {
+    x = x - ((x >>> 1) & 0x55555555);
+    x = (x & 0x33333333) + ((x >>> 2) & 0x33333333);
+    x = (x + (x >>> 4)) & 0x0f0f0f0f;
+    return Math.imul(x, 0x01010101) >>> 24;
+}
+/**
+ * A page of a `CompactSymbolLinkTable`: one bit per id of the page in eight 32-id words, the number
+ * of symbols stored before each word, and the symbols in id order. The words are fields, so a
+ * lookup reads one object before the symbols. The class isn't generic, so natively the words are
+ * 32-bit fields: every write stores an int32.
+ */
+class CompactLinkPage {
+    values;
+    w0;
+    w1;
+    w2;
+    w3;
+    w4;
+    w5;
+    w6;
+    w7;
+    /** Byte `w & 3` of `before0` (words 1 to 3) or of `before1` (words 4 to 7): the values before word `w`. */
+    before0;
+    before1;
+    constructor() {
+        this.values = [];
+        this.w0 = 0;
+        this.w1 = 0;
+        this.w2 = 0;
+        this.w3 = 0;
+        this.w4 = 0;
+        this.w5 = 0;
+        this.w6 = 0;
+        this.w7 = 0;
+        this.before0 = 0;
+        this.before1 = 0;
+    }
+    /** The presence bits of ids `32 * word` to `32 * word + 31`. */
+    word(word) {
+        switch (word) {
+            case 0:
+                return this.w0;
+            case 1:
+                return this.w1;
+            case 2:
+                return this.w2;
+            case 3:
+                return this.w3;
+            case 4:
+                return this.w4;
+            case 5:
+                return this.w5;
+            case 6:
+                return this.w6;
+            default:
+                return this.w7;
+        }
+    }
+    setWord(word, bits) {
+        switch (word) {
+            case 0:
+                this.w0 = bits | 0;
+                break;
+            case 1:
+                this.w1 = bits | 0;
+                break;
+            case 2:
+                this.w2 = bits | 0;
+                break;
+            case 3:
+                this.w3 = bits | 0;
+                break;
+            case 4:
+                this.w4 = bits | 0;
+                break;
+            case 5:
+                this.w5 = bits | 0;
+                break;
+            case 6:
+                this.w6 = bits | 0;
+                break;
+            default:
+                this.w7 = bits | 0;
+        }
+    }
+    /** The index in `values` of the value of `slot` (an id's low bits), or of where it goes. */
+    rank(slot, bits) {
+        const word = slot >> 5;
+        const before = ((word < 4 ? this.before0 : this.before1) >>> ((word & 3) << 3)) & 0xff;
+        return before + bitCount(bits & ((1 << (slot & 31)) - 1));
+    }
+    /** Adds `delta` to the counts of the words after `word`. */
+    shiftCounts(word, delta) {
+        for (let w = word + 1; w < 8; w++) {
+            const step = delta << ((w & 3) << 3);
+            if (w < 4)
+                this.before0 = (this.before0 + step) | 0;
+            else
+                this.before1 = (this.before1 + step) | 0;
+        }
+    }
+}
+/**
+ * Symbols by node id, for ids a checker resolves in one in four to one in eight of the ids of the
+ * pages it touches, as it resolves the identifiers and names of the files it checks. Pages of
+ * `LinkPaging.Size` ids keep a presence bit per id and only the symbols stored, so a symbol costs
+ * about one array slot. A `LinkTable` page costs a slot for every id, and a `Map` entry also
+ * stores its key and a share of the hash buckets. At fewer values per page than that, the page's
+ * own allocations outweigh what it saves, and a `SparseLinkTable` costs less.
+ */
+export class CompactSymbolLinkTable {
+    pages = [];
+    /** The number of symbols stored. */
+    size = 0;
+    get(id) {
+        const page = this.pages[id >> 8 /* LinkPaging.Bits */];
+        if (page === undefined)
+            return undefined;
+        const slot = id & 255 /* LinkPaging.Mask */;
+        const bits = page.word(slot >> 5);
+        if ((bits & (1 << (slot & 31))) === 0)
+            return undefined;
+        return page.values[page.rank(slot, bits)];
+    }
+    set(id, value) {
+        const index = id >> 8 /* LinkPaging.Bits */;
+        let page = this.pages[index];
+        if (page === undefined) {
+            if (value === undefined)
+                return;
+            while (this.pages.length <= index)
+                this.pages.push(undefined);
+            page = new CompactLinkPage();
+            this.pages[index] = page;
+        }
+        const slot = id & 255 /* LinkPaging.Mask */;
+        const word = slot >> 5;
+        const bit = 1 << (slot & 31);
+        const bits = page.word(word);
+        const at = page.rank(slot, bits);
+        const values = page.values;
+        if ((bits & bit) !== 0) {
+            if (value !== undefined) {
+                values[at] = value;
+                return;
+            }
+            for (let i = at; i < values.length - 1; i++)
+                values[i] = values[i + 1];
+            values.pop();
+            page.setWord(word, bits & ~bit);
+            page.shiftCounts(word, -1);
+            this.size--;
+            return;
+        }
+        if (value === undefined)
+            return;
+        values.push(value);
+        for (let i = values.length - 1; i > at; i--)
+            values[i] = values[i - 1];
+        values[at] = value;
+        page.setWord(word, bits | bit);
+        page.shiftCounts(word, 1);
+        this.size++;
+    }
+    clear() {
+        this.pages.length = 0;
+        this.size = 0;
+    }
+}

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

@@ -6,7 +6,7 @@ import { BindingElement, ConditionalTypeNode, HeritageClause, ModuleDeclaration,
 import { isFunctionLike, isFunctionLikeDeclarationKind, isInJSFile, isRequireCall } from './ast-utilities.js';
 import { findConstructorDeclaration, getDeclarationOfKind, getImmediatelyInvokedFunctionExpression, getSourceFileOfNode, hasSyntacticModifier, hasStaticModifier, isClassElement, isClassLike, isConstAssertion, isExternalOrCommonJSModule, isGlobalSourceFile, isNullishCoalesce, isOptionalChain, isPartOfParameterDeclaration, isStatic, isTypeNodeKind, } from './binder-utilities.js';
 import { getEmitScriptTarget, getIsolatedModules, getUseDefineForClassFields, } from './options.js';
-import { Symbol } from './symbol.js';
+import { getDeclarations, Symbol } from './symbol.js';
 export class NameResolver {
     compilerOptions;
     /** The global symbol table; empty unless the checker sets it. */
@@ -459,7 +459,7 @@ function isInParameter(declaration) {
 }
 /** The local symbol of an `export default` declaration. */
 export function getLocalSymbolForExportDefault(symbol) {
-    const declarations = symbol.declarations;
+    const declarations = getDeclarations(symbol);
     if (declarations.length === 0 || !hasSyntacticModifier(declarations[0], 2048 /* ModifierFlags.Default */))
         return undefined;
     for (const declaration of declarations) {
@@ -486,7 +486,7 @@ function isDeferredContext(location, lastLocation) {
     return getImmediatelyInvokedFunctionExpression(location) === undefined;
 }
 function isTypeParameterSymbolDeclaredInContainer(symbol, container) {
-    for (const declaration of symbol.declarations)
+    for (const declaration of getDeclarations(symbol))
         if (declaration.kind === 169 /* SyntaxKind.TypeParameter */ && declaration.parent === container)
             return true;
     return false;

package/dist/api/compiler/node-builder-names.d.ts

@@ -2,8 +2,8 @@ import { type Node, type NodeList, SourceFile } from './ast.js';
 import type { Checker } from './checker.js';
 import { ModuleSpecifierPreferences } from './module-specifiers.js';
 import { ModuleKind } from './options.js';
-import { type Symbol, SymbolFlags } from './symbol.js';
 import { type NodeBuilder } from './node-builder.js';
+import { type Symbol, SymbolFlags } from './symbol.js';
 /** The chain of symbols naming `symbol`, reported to the tracker. */
 export declare function lookupSymbolChain(b: NodeBuilder, symbol: Symbol, meaning: SymbolFlags, yieldModuleSymbol: boolean): Symbol[];
 /** A type node naming `symbol` with `mask`: a type reference, `typeof`, indexed access or `import("…")`. */