tsc-ts 0.0.5 → 0.0.6

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

@@ -2,10 +2,10 @@ import { type Identifier, type Node, type PatternAmbientModule, type SourceFile,
 import { getSourceFileOfNode } from './binder-utilities.js';
 import { type Diagnostic, type DiagnosticMessage } from './diagnostics.js';
 import { NameResolver } from './name-resolver.js';
-import { Symbol, SymbolFlags, type SymbolTable } from './symbol.js';
 import { type Checker } from './checker.js';
 import { type Type, type Signature } from './checker-types.js';
 import { getTypeOfSymbol } from './checker-symbol-types.js';
+import { Symbol, SymbolFlags, type SymbolTable } from './symbol.js';
 /** The binder's name resolver with the checker's merging, alias handling and errors. */
 export declare class CheckerNameResolver extends NameResolver {
     readonly checker: Checker;
@@ -108,7 +108,7 @@ export declare function isAmbientModuleSymbolName(name: string): boolean;
 export declare function mergeSymbolTable(c: Checker, target: SymbolTable, source: SymbolTable, unidirectional: boolean, mergedParent: Symbol | undefined): void;
 /** Merges `source` into `target`, cloning a non-transient target first. */
 export declare function mergeSymbol(c: Checker, target: Symbol, source: Symbol, unidirectional: boolean): Symbol;
-export declare function addDuplicateDeclarationError(c: Checker, node: Node, message: DiagnosticMessage, name: string, relatedNodes: Node[]): void;
+export declare function addDuplicateDeclarationError(c: Checker, node: Node, message: DiagnosticMessage, name: string, relatedNodes: readonly Node[]): void;
 export declare function getExcludedSymbolFlags(flags: SymbolFlags): SymbolFlags;
 export declare function cloneSymbol(c: Checker, symbol: Symbol): Symbol;
 export declare function getMergedSymbol(c: Checker, symbol: Symbol): Symbol;

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

@@ -10,7 +10,6 @@ import { checkResolvedBlockScopedVariable, getEmitStandardClassFields } from './
 import { declarationNameToString, getNameOfDeclaration, getRootDeclaration, getSourceFileOfNode, getSourceTextOfNode, getDeclarationOfKind, getThisContainer, hasStaticModifier, isClassLike, isEntityNameExpression, isExternalOrCommonJSModule, isPartOfTypeQuery, isStatic, } from './binder-utilities.js';
 import { compareDiagnostics } from './diagnostics.js';
 import { NameResolver } from './name-resolver.js';
-import { Symbol, addDeclaration, getSymbolId, } from './symbol.js';
 import { createDiagnosticForNode } from './checker.js';
 import { compareSymbols } from './checker-type-factory.js';
 import { getDeclaredTypeOfSymbol } from './checker-declared-types.js';
@@ -22,6 +21,7 @@ import { getLateBindableNameOfDeclaration, getPropertyNameFromType, isTypeUsable
 import { checkTypeOnlyAliasUse, markAliasDeclarationOfNameIfTypeOnly, getExportsOfModuleWorker, getTargetOfAliasDeclaration, getTypeOnlyAliasDeclaration, isTypeOnlyImportOrExportDeclaration, resolveExternalModuleNameWorker, resolveExternalModuleSymbol, resolveIndirectionAlias, } from './checker-modules.js';
 import { isJSAliasDeclaration } from './checker-javascript.js';
 import { getFeatureMap } from './checker-features.js';
+import { addDeclaration, declarationAt, declarationCount, getDeclarations, getSymbolId, setDeclarations, Symbol, } from './symbol.js';
 // ---- Name resolution
 /** The binder's name resolver with the checker's merging, alias handling and errors. */
 export class CheckerNameResolver extends NameResolver {
@@ -92,8 +92,8 @@ export class CheckerNameResolver extends NameResolver {
             (meaning & 111551 /* SymbolFlags.Value */) === 111551 /* SymbolFlags.Value */ &&
             (location.flags & 4194304 /* NodeFlags.JSDoc */) === 0) {
             const merged = getMergedSymbol(c, result);
-            if (merged.declarations.length !== 0 &&
-                merged.declarations.every((d) => d.kind === 271 /* SyntaxKind.NamespaceExportDeclaration */ ||
+            if (declarationCount(merged) !== 0 &&
+                getDeclarations(merged).every((d) => d.kind === 271 /* SyntaxKind.NamespaceExportDeclaration */ ||
                     (d.kind === 307 /* SyntaxKind.SourceFile */ && d.globalExports !== undefined)))
                 c.addErrorOrSuggestion(c.compilerOptions.allowUmdGlobalAccess !== true, createDiagnosticForNode(location, 819 /* Diagnostics.X_0_refers_to_a_UMD_global_but_the_current_file_is_a_module_Consider_adding_an_import_instead */, [result.name]));
         }
@@ -125,7 +125,7 @@ export class CheckerNameResolver extends NameResolver {
             const locals = isGlobal ? getLocals(lastLocation) : undefined;
             const nonValueSymbol = locals !== undefined ? getSymbolOfMeaning(c, locals, name, ~111551 /* SymbolFlags.Value */) : undefined;
             if (nonValueSymbol !== undefined) {
-                const importDeclaration = nonValueSymbol.declarations.find((d) => d.kind === 277 /* SyntaxKind.ImportSpecifier */ ||
+                const importDeclaration = getDeclarations(nonValueSymbol).find((d) => d.kind === 277 /* SyntaxKind.ImportSpecifier */ ||
                     d.kind === 274 /* SyntaxKind.ImportClause */ ||
                     d.kind === 275 /* SyntaxKind.NamespaceImport */ ||
                     d.kind === 272 /* SyntaxKind.ImportEqualsDeclaration */);
@@ -469,7 +469,7 @@ function mergeFileGlobals(c, file) {
         if (locals !== undefined) {
             const fileGlobalThis = locals.get('globalThis');
             if (fileGlobalThis !== undefined)
-                for (const d of fileGlobalThis.declarations)
+                for (const d of getDeclarations(fileGlobalThis))
                     c.addDiagnostic(createDiagnosticForNode(d, 568 /* Diagnostics.Declaration_name_conflicts_with_built_in_global_identifier_0 */, [
                         'globalThis',
                     ]));
@@ -743,7 +743,7 @@ export function initializeGlobals(c) {
     // addUndefinedToGlobalsOrErrorOnRedeclaration
     const target = globals.get('undefined');
     if (target !== undefined) {
-        for (const declaration of target.declarations)
+        for (const declaration of getDeclarations(target))
             if (!isTypeDeclaration(declaration))
                 c.addDiagnostic(createDiagnosticForNode(declaration, 568 /* Diagnostics.Declaration_name_conflicts_with_built_in_global_identifier_0 */, ['undefined']));
     }
@@ -791,7 +791,7 @@ function mergeModuleAugmentation(c, moduleName) {
     const moduleNode = moduleName.parent;
     const augmentationSymbol = moduleNode.symbol;
     // Several augmentations in one file share a symbol; merge it once.
-    if (augmentationSymbol.declarations[0] !== moduleNode)
+    if (augmentationSymbol.declaration !== moduleNode)
         return;
     if (isGlobalScopeAugmentation(moduleNode)) {
         if (augmentationSymbol.exports !== undefined)
@@ -877,7 +877,7 @@ export function mergeSymbol(c, target, source, unidirectional) {
         target.flags |= sourceFlags;
         if (source.valueDeclaration !== undefined)
             setValueDeclaration(target, source.valueDeclaration);
-        for (const d of source.declarations)
+        for (const d of getDeclarations(source))
             addDeclaration(target, d);
         if (source.members !== undefined) {
             if (target.members === undefined)
@@ -895,7 +895,7 @@ export function mergeSymbol(c, target, source, unidirectional) {
     else if ((target.flags & 1024 /* SymbolFlags.NamespaceModule */) !== 0) {
         // `var globalThis` already reports a conflict with the built-in.
         if (target !== c.globalThisSymbol)
-            c.error(getNameOfDeclaration(source.declarations[0]), 783 /* Diagnostics.Cannot_augment_module_0_with_value_exports_because_it_resolves_to_a_non_module_entity */, symbolToString(c, target));
+            c.error(getNameOfDeclaration(source.declaration), 783 /* Diagnostics.Cannot_augment_module_0_with_value_exports_because_it_resolves_to_a_non_module_entity */, symbolToString(c, target));
     }
     else
         reportMergeSymbolError(c, target, source);
@@ -916,14 +916,14 @@ function reportMergeSymbolError(c, target, source) {
         addDuplicateDeclarationErrors(c, target, message, name, source);
 }
 function isPlainJSFile(symbol) {
-    if (symbol.declarations.length === 0)
+    if (declarationCount(symbol) === 0)
         return false;
-    const file = getSourceFileOfNode(symbol.declarations[0]);
+    const file = getSourceFileOfNode(symbol.declaration);
     return file.isJS() && file.checkJsDirective === undefined;
 }
 function addDuplicateDeclarationErrors(c, target, message, name, source) {
-    for (const node of target.declarations)
-        addDuplicateDeclarationError(c, node, message, name, source.declarations);
+    for (const node of getDeclarations(target))
+        addDuplicateDeclarationError(c, node, message, name, getDeclarations(source));
 }
 export function addDuplicateDeclarationError(c, node, message, name, relatedNodes) {
     const errorNode = getNameOfDeclaration(node) ?? node;
@@ -994,7 +994,7 @@ export function getExcludedSymbolFlags(flags) {
 }
 export function cloneSymbol(c, symbol) {
     const result = c.newSymbol(symbol.flags, symbol.name);
-    result.declarations = symbol.declarations.slice();
+    setDeclarations(result, getDeclarations(symbol).slice());
     result.parent = symbol.parent;
     result.valueDeclaration = symbol.valueDeclaration;
     if (symbol.members !== undefined)
@@ -1010,7 +1010,7 @@ export function cloneSymbol(c, symbol) {
  */
 function copySharedSymbol(c, shared) {
     const result = c.newSymbol(shared.flags, shared.name);
-    result.declarations = shared.declarations.slice();
+    setDeclarations(result, getDeclarations(shared).slice());
     result.parent = shared.parent;
     result.valueDeclaration = shared.valueDeclaration;
     if (shared.members !== undefined)
@@ -1053,7 +1053,7 @@ export function getSymbolOfDeclaration(c, node) {
     return symbol !== undefined ? getMergedSymbol(c, getLateBoundSymbol(c, symbol)) : undefined;
 }
 function hasStaticDeclaration(symbol) {
-    for (const d of symbol.declarations)
+    for (const d of getDeclarations(symbol))
         if (hasStaticModifier(d))
             return true;
     return false;
@@ -1074,7 +1074,7 @@ export function getLateBoundSymbol(c, symbol) {
         else {
             // An `F[name] = …` assignment in a script has no parent. Checking its target late-binds it
             // with the members of the function it's assigned to.
-            for (const declaration of symbol.declarations)
+            for (const declaration of getDeclarations(symbol))
                 if (declaration instanceof BinaryExpression)
                     checkExpressionCached(c, declaration.left);
         }
@@ -1084,7 +1084,7 @@ export function getLateBoundSymbol(c, symbol) {
     return links.lateSymbol;
 }
 function hasLateBindableDeclaration(c, symbol) {
-    for (const declaration of symbol.declarations)
+    for (const declaration of getDeclarations(symbol))
         if (hasLateBindableName(c, declaration))
             return true;
     return false;
@@ -1095,7 +1095,7 @@ export function getGlobalSymbol(c, name, meaning, diagnostic) {
     return resolveName(c, undefined, name, meaning, diagnostic, false, false);
 }
 function getGlobalTypeDeclaration(symbol) {
-    for (const d of symbol.declarations) {
+    for (const d of getDeclarations(symbol)) {
         switch (d.kind) {
             case 264 /* SyntaxKind.ClassDeclaration */:
             case 265 /* SyntaxKind.InterfaceDeclaration */:
@@ -1187,8 +1187,8 @@ export function resolveSymbolEx(c, symbol, dontResolveAlias) {
     return symbol;
 }
 export function getDeclarationOfAliasSymbol(symbol) {
-    for (let i = symbol.declarations.length - 1; i >= 0; i--) {
-        const d = symbol.declarations[i];
+    for (let i = declarationCount(symbol) - 1; i >= 0; i--) {
+        const d = declarationAt(symbol, i);
         if (isAliasSymbolDeclaration(d))
             return d;
     }
@@ -1323,7 +1323,7 @@ function getResolvedMembersOrExports(c, symbol, isStatic) {
     else
         links.resolvedMembers = early;
     let late;
-    for (const decl of symbol.declarations) {
+    for (const decl of getDeclarations(symbol)) {
         const members = getMembersOfDeclaration(decl);
         if (members === undefined)
             continue;
@@ -1345,7 +1345,7 @@ function getResolvedMembersOrExports(c, symbol, isStatic) {
     // JavaScript `F[name] = …` assignments with late-bindable names.
     const assignments = isStatic ? symbol.exports?.get("\uFFFEassignment" /* InternalSymbolName.AssignmentDeclaration */) : undefined;
     if (assignments !== undefined)
-        for (const member of assignments.declarations)
+        for (const member of getDeclarations(assignments))
             if (hasLateBindableName(c, member)) {
                 if (late === undefined)
                     late = new Map();
@@ -1401,7 +1401,9 @@ function lateBindMember(c, parent, early, late, decl) {
         }
         const earlySymbol = early.get(memberName);
         if ((lateSymbol.flags & getExcludedSymbolFlags(symbolFlags)) !== 0) {
-            const declarations = earlySymbol !== undefined ? earlySymbol.declarations.concat(lateSymbol.declarations) : lateSymbol.declarations;
+            const declarations = earlySymbol !== undefined
+                ? getDeclarations(earlySymbol).concat(getDeclarations(lateSymbol))
+                : getDeclarations(lateSymbol);
             const name = (type.flags & 16384) !== 0 ? declarationNameToString(getSourceFileOfNode(declName), declName) : memberName;
             for (const d of declarations)
                 c.error(getNameOfDeclaration(d) ?? d, 478 /* Diagnostics.Duplicate_identifier_0 */, name);
@@ -1430,13 +1432,13 @@ function lateBindIndexSignature(c, early, late, decl) {
         late.set("\uFFFEindex" /* InternalSymbolName.Index */, indexSymbol);
     }
     // Unlike late-bound members, `decl` gets no late symbol: the index symbol isn't one property.
-    if (indexSymbol.declarations.length === 0 || (getSymbol(decl).flags & 536870912 /* SymbolFlags.ReplaceableByMethod */) === 0)
+    if (declarationCount(indexSymbol) === 0 || (getSymbol(decl).flags & 536870912 /* SymbolFlags.ReplaceableByMethod */) === 0)
         addDeclaration(indexSymbol, decl);
 }
 function addDeclarationToLateBoundSymbol(c, symbol, member, symbolFlags) {
     const memberSymbol = getSymbol(member);
     c.symbolLinks(memberSymbol).lateSymbol = symbol;
-    if (symbol.declarations.length === 0 || (memberSymbol.flags & 536870912 /* SymbolFlags.ReplaceableByMethod */) === 0) {
+    if (declarationCount(symbol) === 0 || (memberSymbol.flags & 536870912 /* SymbolFlags.ReplaceableByMethod */) === 0) {
         symbol.flags |= symbolFlags;
         addDeclaration(symbol, member);
     }
@@ -1457,7 +1459,7 @@ export function symbolIsValue(c, symbol) {
 function isDeclarationContainedBy(symbol, container) {
     const declaration = symbol.valueDeclaration;
     if (declaration !== undefined)
-        for (const d of container.declarations)
+        for (const d of getDeclarations(container))
             if (declaration.pos >= d.pos && declaration.end <= d.end)
                 return true;
     return false;

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

@@ -1,7 +1,7 @@
 import { type Node } from './ast.js';
-import { type Symbol, type SymbolTable } from './symbol.js';
 import type { Checker } from './checker.js';
 import { ElementFlags, IndexInfo, IndexType, IndexedAccessType, IntersectionType, LiteralType, ObjectFlags, ObjectType, Signature, StructuredType, SubstitutionType, TupleElementInfo, TupleType, type Type, TypeAlias, TypeFlags, TypeMapper, TypeReference, UnionType } from './checker-types.js';
+import { type Symbol, type SymbolTable } from './symbol.js';
 export declare const enum UnionReduction {
     None = 0,
     Literal = 1,
@@ -22,7 +22,7 @@ export declare function typeListHash(types: readonly Type[], alias: TypeAlias |
 export declare function newObjectType(c: Checker, objectFlags: ObjectFlags, symbol: Symbol | undefined): ObjectType;
 export declare function newAnonymousType(c: Checker, symbol: Symbol | undefined): ObjectType;
 export declare function createAnonymousType(c: Checker, symbol: Symbol | undefined, members: SymbolTable | undefined, callSignatures: Signature[], constructSignatures: Signature[], indexInfos: IndexInfo[]): ObjectType;
-export declare function setStructuredTypeMembers(c: Checker, t: StructuredType, members: SymbolTable | undefined, callSignatures: Signature[], constructSignatures: Signature[], indexInfos: IndexInfo[]): void;
+export declare function setStructuredTypeMembers(c: Checker, t: Type, members: SymbolTable | undefined, callSignatures: Signature[], constructSignatures: Signature[], indexInfos: IndexInfo[]): void;
 export declare function newUnionType(c: Checker, objectFlags: ObjectFlags, types: Type[]): UnionType;
 export declare function newIntersectionType(c: Checker, objectFlags: ObjectFlags, types: Type[]): IntersectionType;
 export declare function newIndexType(c: Checker, target: Type, indexFlags: number): IndexType;

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

@@ -8,7 +8,6 @@ import { getAliasForTypeNode, getTypeArgumentsOfDeferredReference } from './chec
 import { popTypeResolution, pushTypeResolution } from './checker-symbols.js';
 import { isGenericIndexType } from './checker-type-operators.js';
 import { compareCodePoints } from './diagnostics.js';
-import { getSymbolId } from './symbol.js';
 import { cachedTypeKey, EvolvingArrayType, IndexInfo, IndexType, IndexedAccessType, InstantiationExpressionType, InterfaceType, IntersectionType, MappedType, ObjectType, ReverseMappedType, SubstitutionType, TemplateLiteralType, TupleElementInfo, TupleType, TypeAlias, TypeReference, UnionType, ArrayTypeMapper, ArrayToSingleTypeMapper, MergedTypeMapper, SimpleTypeMapper, emptyIndexInfos, emptySignatures, emptySymbols, emptyTypes, ReferenceCache, } from './checker-types.js';
 import { getNamedMembers, getMembersOfSymbol } from './checker-symbols.js';
 import { getBaseConstraintOfType, getBaseConstraintOrType, getIndexTypeOfType, getPropertiesOfType, getTypeOfPropertyOfType, isArrayLikeType, resolveStructuredTypeMembers, hasResolvedProperties, memberResolutionFlags, membersHolder, } from './checker-members.js';
@@ -19,6 +18,7 @@ import { getIndexedAccessType, isGenericMappedType, isTypeMatchedByTemplateLiter
 import { addOptionality } from './checker-symbol-types.js';
 import { getSourceFileOfNode } from './binder-utilities.js';
 import { isPartOfTypeNode } from './transformers/alias-references.js';
+import { declarationCount, getSymbolId } from './symbol.js';
 // ---- Keys
 export function typeListKey(types) {
     let key = '';
@@ -418,14 +418,14 @@ export function compareSymbols(c, s1, s2) {
         return 1;
     if (s2 === undefined)
         return -1;
-    if (s1.declarations.length !== 0 && s2.declarations.length !== 0) {
-        const r = compareNodes(c, s1.declarations[0], s2.declarations[0]);
+    if (declarationCount(s1) !== 0 && declarationCount(s2) !== 0) {
+        const r = compareNodes(c, s1.declaration, s2.declaration);
         if (r !== 0)
             return r;
     }
-    else if (s1.declarations.length !== 0)
+    else if (declarationCount(s1) !== 0)
         return -1;
-    else if (s2.declarations.length !== 0)
+    else if (declarationCount(s2) !== 0)
         return 1;
     const r = compareCodePoints(s1.name, s2.name);
     if (r !== 0)
@@ -490,6 +490,19 @@ function compareTypeLists(c, s1, s2) {
     }
     return 0;
 }
+/** compareTypeLists of the targets of two array mappers. */
+function compareMapperTargets(c, a, b) {
+    const n1 = a.targetCount();
+    const n2 = b.targetCount();
+    if (n1 !== n2)
+        return n1 - n2;
+    for (let i = 0; i < n1; i++) {
+        const r = compareTypes(c, a.targetAt(i), b.targetAt(i));
+        if (r !== 0)
+            return r;
+    }
+    return 0;
+}
 function compareElementLabels(n1, n2) {
     if (n1 === n2)
         return 0;
@@ -544,7 +557,7 @@ export function compareTypeMappers(c, m1, m2) {
             const a = m1;
             const b = m2;
             const r = compareTypeLists(c, a.sources, b.sources);
-            return r !== 0 ? r : compareTypeLists(c, a.targets, b.targets);
+            return r !== 0 ? r : compareMapperTargets(c, a, b);
         }
         case 3 /* TypeMapperKind.Merged */: {
             const a = m1;
@@ -591,9 +604,9 @@ function declarationPlaces(c, t) {
     const queue = [t];
     const seen = new Set();
     const visit = (symbol) => {
-        if (symbol === undefined || symbol.declarations.length === 0)
+        if (symbol === undefined || declarationCount(symbol) === 0)
             return;
-        const node = symbol.declarations[0];
+        const node = symbol.declaration;
         const file = sourceFileOf(node);
         (file.isDeclarationFile ? libraryPlaces : places).push((c.fileIndex.get(file) ?? 0) * 0x4000000 + node.pos);
     };
@@ -603,8 +616,8 @@ function declarationPlaces(c, t) {
         if (m instanceof SimpleTypeMapper)
             queue.push(m.target);
         else if (m instanceof ArrayTypeMapper)
-            for (const u of m.targets)
-                queue.push(u);
+            for (let i = 0; i < m.targetCount(); i++)
+                queue.push(m.targetAt(i));
         else if (m instanceof ArrayToSingleTypeMapper)
             queue.push(m.target);
         else if (m instanceof MergedTypeMapper || m instanceof CompositeTypeMapper) {
@@ -912,14 +925,42 @@ export function unionContainsType(c, union, t) {
     if (types.length < linearTypeSearchLimit)
         return indexOfType(types, t, 0) >= 0;
     const side = sideOf(c, union);
-    let set = side.constituentSet;
-    if (set === undefined) {
+    let table = side.constituentIds;
+    if (table === undefined) {
         if (side.membershipTests++ === 0)
             return binarySearchTypes(c, types, t) >= 0;
-        set = new Set(types);
-        side.constituentSet = set;
+        table = constituentTable(types);
+        side.constituentIds = table;
+    }
+    // Type ids are unique within a checker, so a matching id is `t` itself.
+    const key = t.id + 1;
+    const mask = table.length - 1;
+    for (let slot = Math.imul(key, 0x9e3779b1) & mask;; slot = (slot + 1) & mask) {
+        const value = table[slot];
+        if (value === key)
+            return true;
+        if (value === 0)
+            return false;
+    }
+}
+/**
+ * An open-addressing table of the ids of `types` (each plus one; zero marks an empty slot), with at
+ * least twice as many slots as types so that probes stay short.
+ */
+function constituentTable(types) {
+    let size = 4;
+    while (size < types.length * 2)
+        size *= 2;
+    const table = new Int32Array(size);
+    const mask = size - 1;
+    for (const t of types) {
+        const key = t.id + 1;
+        let slot = Math.imul(key, 0x9e3779b1) & mask;
+        while (table[slot] !== 0)
+            slot = (slot + 1) & mask;
+        table[slot] = key;
     }
-    return set.has(t);
+    return table;
 }
 /**
  * Whether `union` contains every type of the sorted `types` (the constituents of another union).
@@ -2046,7 +2087,7 @@ export function createTypeReferenceEx(c, target, typeArguments, objectFlags) {
         return existing;
     const type = newObjectType(c, 4 /* ObjectFlags.Reference */ | objectFlags | getPropagatingFlagsOfTypes(typeArguments, 0 /* TypeFlags.None */), target.symbol);
     type.target = target;
-    type.resolvedTypeArguments = typeArguments;
+    type.resolvedTypeArguments = c.typeLists.intern(hash, typeArguments);
     references.add(hash, type);
     return type;
 }

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

@@ -1,7 +1,7 @@
 import { type IndexedAccessTypeNode, type Node } from './ast.js';
-import { type Symbol, SymbolFlags } from './symbol.js';
 import type { Checker } from './checker.js';
 import { ElementFlags, type InterfaceType, type Type, TypeAlias } from './checker-types.js';
+import { type Symbol, SymbolFlags } from './symbol.js';
 export declare function getTypeFromTypeNode(c: Checker, node: Node): Type;
 export declare function getTypeFromThisTypeNode(c: Checker, node: Node): Type;
 export declare function getTypeFromIndexedAccessTypeNode(c: Checker, node: IndexedAccessTypeNode): Type;

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

@@ -1,7 +1,6 @@
 // Types from type nodes: `getTypeFromTypeNode` and the resolution of type references.
 import { getExpression, getName, getText, getType, getSymbol, getBody, getTypeArguments, } from './ast.js';
 import { declarationNameToString, getSourceFileOfNode, getThisContainer, isClassLike, isStatic, isDeclarationStatementKind, } from './binder-utilities.js';
-import { getSymbolId } from './symbol.js';
 import { TupleElementInfo, TypeAlias, UniqueESSymbolType, emptyTypes, newTypeMapper, } from './checker-types.js';
 import { createArrayType, aliasKey, createDeferredTypeReference, createNormalizedTupleType, createTypeReferenceEx, getIntersectionTypeEx, getRegularTypeOfLiteralType, getTemplateLiteralType, getTupleTargetType, getUnionTypeEx, getIntersectionType, everyType, isArrayOrTupleType, isPatternLiteralType, newObjectType, typeListKey, } from './checker-type-factory.js';
 import { getMembersOfSymbol, getMergedSymbol, getSymbolOfDeclaration, resolveAlias, resolveEntityName, } from './checker-symbols.js';
@@ -15,6 +14,7 @@ import { checkExpression, checkExpressionCached, getResolvedSymbol } from './che
 import { checkExpressionWithTypeArguments } from './checker-calls.js';
 import { getIntendedTypeFromJSDocTypeReference } from './checker-jsdoc.js';
 import { getCombinedNodeFlags, hasSyntacticModifier } from './binder-utilities.js';
+import { getDeclarations, getSymbolId } from './symbol.js';
 export function getTypeFromTypeNode(c, node) {
     return getConditionalFlowTypeOfType(c, getTypeFromTypeNodeWorker(c, node), node);
 }
@@ -568,7 +568,7 @@ export function getAliasSymbolForTypeNode(c, node) {
 }
 function isLocalTypeAlias(symbol) {
     let declaration;
-    for (const d of symbol.declarations) {
+    for (const d of getDeclarations(symbol)) {
         if (isTypeAlias(d)) {
             declaration = d;
             break;

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

@@ -1,7 +1,7 @@
 import { type Node } from './ast.js';
-import { type Symbol } from './symbol.js';
 import type { Checker } from './checker.js';
 import { AccessFlags, ConditionalRoot, ConditionalType, IndexFlags, IndexedAccessType, type MappedType, type TemplateLiteralType, type Type, type TypeAlias, TypeFlags, type TypeMapper, type TypeParameter, type TupleType, type UnionType } from './checker-types.js';
+import { type Symbol } from './symbol.js';
 export declare function isGenericType(c: Checker, t: Type): boolean;
 export declare function isGenericObjectType(c: Checker, t: Type): boolean;
 export declare function isGenericIndexType(c: Checker, t: Type): boolean;

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

@@ -5,7 +5,6 @@ import { getTypeOfPropertyOfContextualType } from './checker-contextual.js';
 import { checkDeprecatedIndexedAccess } from './checker-deprecation.js';
 import { isSelfTypeAccess, markPropertyAsReferenced } from './checker-unused.js';
 import { getName, getQuestionToken, getType, getSymbol, getDotDotDotToken, getElements, getExpression, getText, } from './ast.js';
-import { getSymbolId } from './symbol.js';
 import { cachedTypeKey, ConditionalRoot, ConditionalType, IndexInfo, StringMappingType, appendTypeMapping, prependTypeMapping, newTypeMapper, ReferenceArgs, } from './checker-types.js';
 import { aliasKey, createArrayTypeEx, createTupleTypeEx, everyType, filterType, getElementTypes, getIntersectionType, getIntersectionTypeEx, getRegularTypeOfLiteralType, getStringLiteralType, getTemplateLiteralType, getTotalFixedElementCount, getTypeArguments, getUnionType, getUnionTypeEx, isArrayType, isEmptyAnonymousObjectType, isErrorType, isGenericStringLikeType, isGenericTupleType, isPatternLiteralType, isReadonlyArrayType, isTupleType, mapType, mapTypeEx, intersectTypes, mapTypeWithAlias, newIndexType, newIndexedAccessType, newObjectType, newSubstitutionType, setStructuredTypeMembers, someType, tupleTargetOf, typeListKey, typesOf, typeListHash, } from './checker-type-factory.js';
 import { appendIndexInfo, getApparentType, getApplicableIndexInfo, getDeclarationModifierFlagsFromSymbol, getIndexInfoOfType, getPropertyOfObjectType, getIndexInfosOfType, getPropertiesOfType, getPropertyOfType, getReducedApparentType, getReducedType, getBaseConstraintOfType, getIndexTypeOfType, hasPropertiesOfType, keepPropertiesOnly, memberResolutionFlags, } from './checker-members.js';
@@ -24,6 +23,7 @@ import { getSuggestionForNonexistentProperty, isAssignmentToReadonlyEntity, isDe
 import { checkComputedPropertyName, checkExpression } from './checker-expressions.js';
 import { getPropertyNameFromType, isNumericLiteralName, isTypeUsableAsPropertyName, isValidIndexKeyType, maybeTypeOfKind, isLateBoundName, } from './checker-utilities.js';
 import { inferTypesForConditional, inferTypesFromTemplateLiteralType, isValidBigIntString, isValidNumberString, instantiateReverseMappedType as instantiateReverseMappedTypeOfInference, resolveReverseMappedTypeMembers as resolveReverseMappedTypeMembersOfInference, } from './checker-inference.js';
+import { copyDeclarations, declarationCount, getSymbolId, } from './symbol.js';
 // ---- Genericity
 export function isGenericType(c, t) {
     return getGenericObjectFlags(c, t) !== 0;
@@ -1155,7 +1155,7 @@ export function resolveMappedTypeMembers(c, t) {
             if (modifiersProp !== undefined) {
                 c.symbolSyntheticOrigins.set(symbolId, modifiersProp);
                 if (shouldLinkPropDeclarations)
-                    prop.declarations = modifiersProp.declarations;
+                    copyDeclarations(prop, modifiersProp);
             }
             members.set(propName, prop);
         }
@@ -1632,7 +1632,7 @@ function computeReferenceArgs(c, root) {
         let kind = 0 /* ReferenceArgKind.Fixed */;
         let inferTypeParameter;
         for (const tp of root.inferTypeParameters) {
-            const declaration = tp.symbol?.declarations[0];
+            const declaration = tp.symbol?.declaration;
             if (declaration === undefined ||
                 isNodeDescendantOf(declaration, argNode) ||
                 containsTypeParameterReference(c, tp, argNode)) {
@@ -1643,8 +1643,8 @@ function computeReferenceArgs(c, root) {
         if (kind === 3 /* ReferenceArgKind.Other */) {
             const inner = skipTypeParentheses(argNode);
             if (inner.kind === 196 /* SyntaxKind.InferType */) {
-                const tp = root.inferTypeParameters.find((t) => t.symbol.declarations[0] === inner.typeParameter);
-                if (tp !== undefined && tp.symbol.declarations.length === 1 && !isReferencedInOtherArg(c, tp, argNodes, i)) {
+                const tp = root.inferTypeParameters.find((t) => t.symbol.declaration === inner.typeParameter);
+                if (tp !== undefined && declarationCount(tp.symbol) === 1 && !isReferencedInOtherArg(c, tp, argNodes, i)) {
                     kind = 1 /* ReferenceArgKind.Infer */;
                     inferTypeParameter = tp;
                 }

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

@@ -300,12 +300,42 @@ export declare class TypeAlias {
  * 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 declare class TypeListCache<V> {
-    private readonly entries;
+    private heads;
+    private lists;
+    private values;
+    private aliases;
+    private tags;
+    /** The next entry with the same hash, or -1. */
+    private nexts;
+    constructor();
     get(hash: number, types: readonly Type[], alias: TypeAlias | undefined, tag: number): V | undefined;
     set(hash: number, types: readonly Type[], alias: TypeAlias | undefined, tag: number, value: V): void;
     clear(): void;
+    /** The number of the entry with these parts, or -1. */
+    private find;
+    private findFrom;
+}
+/**
+ * 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 declare class TypeListTable {
+    private readonly heads;
+    private readonly lists;
+    /** The next list with the same hash, or -1, once two lists share one. */
+    private nexts;
+    /**
+     * 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: number, types: Type[]): Type[];
 }
 /**
  * The references to a generic class, interface or tuple type, by the hash of their type arguments
@@ -336,7 +366,7 @@ export declare class TypeExtra implements ProgramLifetime {
     origin: Type | undefined;
     keyPropertyName: string;
     constituentMap: Map<Type, Type> | undefined;
-    constituentSet: Set<Type> | undefined;
+    constituentIds: Int32Array | undefined;
     membershipTests: number;
     uniqueLiteralFilledInstantiation: Type | undefined;
     constructor();
@@ -587,13 +617,27 @@ export declare class EvolvingArrayType extends ObjectType {
     finalArrayType: Type | undefined;
     constructor(objectFlags: ObjectFlags, id: number);
 }
-export declare 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 declare class UnionOrIntersectionType extends Type {
     readonly types: Type[];
+    membersOf: UnionOrIntersectionMembers | undefined;
+    constructor(flags: TypeFlags, objectFlags: ObjectFlags, id: number, types: Type[]);
+}
+/**
+ * The resolved members of a union or intersection (`membersHolder`) and the caches of its
+ * properties, created on first use.
+ */
+export declare class UnionOrIntersectionMembers extends StructuredType {
     propertyCache: SymbolTable | undefined;
     propertyCacheWithoutFunctionPropertyAugment: SymbolTable | undefined;
     resolvedProperties: Symbol[] | undefined;
-    constructor(flags: TypeFlags, objectFlags: ObjectFlags, id: number, types: Type[]);
+    constructor(flags: TypeFlags, id: number);
 }
+/** The members holder of a union or intersection, created if it has none yet. */
+export declare function unionOrIntersectionMembers(t: UnionOrIntersectionType): UnionOrIntersectionMembers;
 /** A union; all of its own fields are rarely set and live in `extra`. */
 export declare class UnionType extends UnionOrIntersectionType {
     constructor(objectFlags: ObjectFlags, id: number, types: Type[]);
@@ -609,9 +653,13 @@ export declare class UnionType extends UnionOrIntersectionType {
     set keyPropertyName(name: string);
     get constituentMap(): Map<Type, Type> | undefined;
     set constituentMap(map: Map<Type, Type> | undefined);
-    /** The constituents of a large union, for membership tests; created on the second test. */
-    get constituentSet(): Set<Type> | undefined;
-    set constituentSet(set: Set<Type> | undefined);
+    /**
+     * 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(): Int32Array | undefined;
+    set constituentIds(ids: Int32Array | undefined);
     get membershipTests(): number;
     set membershipTests(tests: number);
 }
@@ -824,6 +872,22 @@ export declare class ArrayTypeMapper extends TypeMapper {
     map(type: Type): Type;
     kind(): TypeMapperKind;
     mapsThisOnly(): boolean;
+    /** The number of targets, one per source. */
+    targetCount(): number;
+    /** The target of the source at `index`. */
+    targetAt(index: number): Type;
+}
+/**
+ * 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 declare class ThisArgumentTypeMapper extends ArrayTypeMapper {
+    readonly thisTarget: Type;
+    constructor(sources: Type[], typeArguments: Type[], thisTarget: Type);
+    map(type: Type): Type;
+    targetCount(): number;
+    targetAt(index: number): Type;
 }
 /** An ArrayTypeMapper that looks its sources up in an index, built on its first lookup. */
 export declare class IndexedArrayTypeMapper extends ArrayTypeMapper {
@@ -850,6 +914,8 @@ export declare class MergedTypeMapper extends TypeMapper {
     kind(): TypeMapperKind;
 }
 export declare function newTypeMapper(sources: Type[], targets: Type[]): TypeMapper;
+/** `newTypeMapper(sources, [...typeArguments, thisTarget])`, without building that list where it can. */
+export declare function newThisArgumentTypeMapper(sources: Type[], typeArguments: Type[], thisTarget: Type): TypeMapper;
 export declare function mergeTypeMappers(m1: TypeMapper | undefined, m2: TypeMapper): TypeMapper;
 export declare function prependTypeMapping(source: Type, target: Type, mapper: TypeMapper | undefined): TypeMapper;
 export declare function appendTypeMapping(mapper: TypeMapper | undefined, source: Type, target: Type): TypeMapper;