tsc-ts 0.0.5 → 0.0.6

package/dist/api/compiler/program.js

@@ -62,13 +62,21 @@ export class Program {
                 this.programDiagnosticsList.push(diagnostic);
             for (const path of previous.emitBlockingPaths)
                 this.emitBlockingPaths.add(path);
-            this.symlinks = previous.symlinks;
+            // The files and include reasons it takes from a program shared with checker threads are immutable, and
+            // so is that program's symlink cache: this one computes its own then (`getSymlinkCache`).
+            this.shared = previous.shared;
+            if (!previous.shared)
+                this.symlinks = previous.symlinks;
+            // The same files are emitted, so the common source directory is the same. Its diagnostics are those
+            // `previous` was created with (`IncludeProcessor.copy`).
+            this.commonSourceDirectoryValue = previous.commonSourceDirectoryValue;
         }
         else {
             this.processed = (loader ?? new FileLoader(host, commandLine)).load();
             this.includeProcessor = this.processed.includeProcessor;
             this.verifyCompilerOptions();
         }
+        this.includeProcessor.noteProgramCreated();
     }
     /**
      * The program with the file at `path` read again from `host` and everything else taken from this program,

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

@@ -1,12 +1,12 @@
 import { ModifierFlags, type Node } from './ast.js';
 import { Diagnostic, type DiagnosticMessage } from './diagnostics.js';
-import { type Symbol } from './symbol.js';
 import { type Checker } from './checker.js';
 import { type IndexInfo, type MappedType, type Signature, SignatureKind, Ternary, type Type, type UnionType, VarianceFlags } from './checker-types.js';
 import { typeListKey } from './checker-type-factory.js';
 import { findApplicableIndexInfo } from './checker-members.js';
 import { getMergedSymbol } from './checker-symbols.js';
 import { getPropertyNameFromType } from './checker-utilities.js';
+import { type Symbol } from './symbol.js';
 export declare const enum RelationComparisonResult {
     None = 0,
     Succeeded = 1,

package/dist/api/compiler/relations.js

@@ -5,7 +5,6 @@ import { getExpression, getName, getNodeId, getText, } from './ast.js';
 import { getSymbolNameForPrivateIdentifier } from './binder.js';
 import { getCombinedModifierFlags } from './binder-utilities.js';
 import { Diagnostic, messageElidedInCompatibilityPyramid } from './diagnostics.js';
-import { getSymbolId } from './symbol.js';
 import { isContextSensitive } from './checker-functions.js';
 import { createDiagnosticForNode } from './checker.js';
 import { cachedTypeKey, emptyTypes, newTypeMapper, SimpleTypeMapper, } from './checker-types.js';
@@ -23,6 +22,7 @@ import { getConstraintOfDistributiveConditionalType, getDefaultConstraintOfCondi
 import { getCanonicalSignature, getErasedSignature, getMinArgumentCount, getNonArrayRestType, getNonCircularReturnTypeOfSignature, getParameterCount, getParameterNameAtPosition, getRestOrAnyTypeAtPosition, getReturnTypeOfSignature, getSingleCallSignature, getThisTypeOfSignature, getTypeAtPosition, getTypePredicateOfSignature, hasEffectiveRestParameter, instantiateSignatureInContextOf, isTopSignature, tryGetTypeAtPosition, } from './checker-signatures.js';
 import { getNonNullableType, getTypeFacts } from './checker-flow.js';
 import { getPropertyNameFromType, isLateBoundName, isNumericLiteralName, maybeTypeOfKind, } from './checker-utilities.js';
+import { declarationCount, getDeclarations, getSymbolId } from './symbol.js';
 /**
  * Cached results of one relation by numeric relation key (see getRelationKey): an open-addressing
  * table of keys and one-byte results. Keys are never 0 (packed keys are positive, interned ones
@@ -430,8 +430,8 @@ function isEnumTypeRelatedTo(c, source, target, reporter) {
             c.enumRelation.set(key, 2 /* RelationComparisonResult.Failed */);
             return false;
         }
-        const sourceDecl = sourceProperty.declarations.find((d) => d.kind === 306 /* SyntaxKind.EnumMember */);
-        const targetDecl = targetProperty.declarations.find((d) => d.kind === 306 /* SyntaxKind.EnumMember */);
+        const sourceDecl = getDeclarations(sourceProperty).find((d) => d.kind === 306 /* SyntaxKind.EnumMember */);
+        const targetDecl = getDeclarations(targetProperty).find((d) => d.kind === 306 /* SyntaxKind.EnumMember */);
         if (sourceDecl === undefined || targetDecl === undefined)
             continue;
         computeEnumMemberValues(c, sourceDecl.parent);
@@ -933,8 +933,8 @@ export class Relater extends TypeComparer {
                             ]);
                         return true;
                     }
-                    const objectLiteralDeclaration = source.symbol !== undefined && source.symbol.declarations.length !== 0
-                        ? source.symbol.declarations[0]
+                    const objectLiteralDeclaration = source.symbol !== undefined && declarationCount(source.symbol) !== 0
+                        ? source.symbol.declaration
                         : undefined;
                     const valueDeclaration = prop.valueDeclaration;
                     let suggestion = undefined;
@@ -2202,8 +2202,8 @@ export class Relater extends TypeComparer {
                 names[0],
                 names[1],
             ]);
-            if (unmatchedProperty.declarations.length !== 0)
-                this.relatedInfo.push(createDiagnosticForNode(unmatchedProperty.declarations[0], 860 /* Diagnostics.X_0_is_declared_here */, [propName]));
+            if (declarationCount(unmatchedProperty) !== 0)
+                this.relatedInfo.push(createDiagnosticForNode(unmatchedProperty.declaration, 860 /* Diagnostics.X_0_is_declared_here */, [propName]));
         }
         else if (this.tryElaborateArrayLikeErrors(source, target, false)) {
             const names = getTypeNamesForErrorDisplay(c, source, target);
@@ -2547,12 +2547,12 @@ export class Relater extends TypeComparer {
         this.reportRelationError(headMessage, source, target);
         if ((source.flags & 524288 /* TypeFlags.TypeParameter */) !== 0 &&
             source.symbol !== undefined &&
-            source.symbol.declarations.length !== 0 &&
+            declarationCount(source.symbol) !== 0 &&
             getConstraintOfType(c, source) === undefined) {
             const syntheticParam = cloneTypeParameter(c, source);
             syntheticParam.constraint = instantiateType(c, target, new SimpleTypeMapper(source, syntheticParam));
             if (hasNonCircularBaseConstraint(c, syntheticParam)) {
-                this.relatedInfo.push(createDiagnosticForNode(source.symbol.declarations[0], 473 /* Diagnostics.This_type_parameter_might_need_an_extends_0_constraint */, [typeToString(c, target)]));
+                this.relatedInfo.push(createDiagnosticForNode(source.symbol.declaration, 473 /* Diagnostics.This_type_parameter_might_need_an_extends_0_constraint */, [typeToString(c, target)]));
             }
         }
     }
@@ -3476,7 +3476,7 @@ import { getTypeAliasInstantiation } from './checker-type-nodes.js';
 export function getTypeParameterModifiers(tp) {
     let flags = 0;
     if (tp.symbol !== undefined)
-        for (const d of tp.symbol.declarations)
+        for (const d of getDeclarations(tp.symbol))
             flags |= getCombinedModifierFlags(d);
     return flags & (8192 /* ModifierFlags.In */ | 16384 /* ModifierFlags.Out */ | 4096 /* ModifierFlags.Const */);
 }

package/dist/api/compiler/symbol-accessibility.d.ts

@@ -1,7 +1,7 @@
 import { type Node, type SourceFile } from './ast.js';
 import { type Checker } from './checker.js';
-import { type Symbol, SymbolFlags, type SymbolTable } from './symbol.js';
 import { SymbolAccessibilityResult } from './transformers/declarations-resolver.js';
+import { type Symbol, SymbolFlags, type SymbolTable } from './symbol.js';
 export declare function isTypeSymbolAccessible(c: Checker, symbol: Symbol, enclosingDeclaration: Node | undefined): boolean;
 export declare function isValueSymbolAccessible(c: Checker, symbol: Symbol, enclosingDeclaration: Node | undefined): boolean;
 export declare function isSymbolAccessibleByFlags(c: Checker, symbol: Symbol, enclosingDeclaration: Node | undefined, flags: SymbolFlags): boolean;

package/dist/api/compiler/symbol-accessibility.js

@@ -4,7 +4,7 @@
 import { BinaryExpression, BindingElement, BindingPattern, ClassExpression, ExportDeclaration, ImportEqualsDeclaration, VariableDeclaration, getExpression, getInitializer, getLocals, getName, getNodeId, getText, getType, } from './ast.js';
 import { isAmbientModule, isInJSFile } from './ast-utilities.js';
 import { getCombinedModifierFlags, getRootDeclaration, getSourceFileOfNode, hasSyntacticModifier, isAccessExpression, isEntityNameExpression, isExportsIdentifier, isExternalModule, isExternalOrCommonJSModule, isGlobalSourceFile, isModuleExportsAccessExpression, } from './binder-utilities.js';
-import { SymbolAccessibilityCaches } from './checker.js';
+import { ExternalModuleContainerIndex, SymbolAccessibilityCaches, fileIndexScale } from './checker.js';
 import { getEffectiveDeclarationFlags } from './checker-declarations.js';
 import { getDeclaredTypeOfSymbol } from './checker-declared-types.js';
 import { checkExpressionCached } from './checker-expressions.js';
@@ -12,11 +12,11 @@ import { resolveExternalModuleName, resolveExternalModuleSymbol } from './checke
 import { getExportsOfSymbol, getMergedSymbol, getParentOfSymbol, getSymbolFlags, getSymbolOfDeclaration, resolveAlias, resolveSymbol, } from './checker-symbols.js';
 import { getTypeOfSymbol } from './checker-symbol-types.js';
 import { compareSymbols } from './checker-type-factory.js';
-import { getSymbolId } from './symbol.js';
 import { SymbolAccessibilityResult, accessible } from './transformers/declarations-resolver.js';
 import { getAnyImportSyntax, getDeclarationContainer, isExternalModuleAugmentation, isLateVisibilityPaintedStatement, } from './transformers/declarations-syntactic.js';
 import { isImplicitlyExportedJSDocDeclaration } from './binder-utilities.js';
 import { symbolToString } from './type-printer.js';
+import { declarationCount, getDeclarations, getSymbolId, } from './symbol.js';
 const tableKindScale = 2 ** 44;
 function tableId(kind, id) {
     return kind * tableKindScale + id;
@@ -61,7 +61,7 @@ function isSymbolAccessibleWorker(c, symbol, enclosingDeclaration, meaning, shou
         return result;
     // A symbol not exported from its module, or from another module without an alias, can't be named.
     let symbolExternalModule = undefined;
-    for (const d of symbol.declarations) {
+    for (const d of getDeclarations(symbol)) {
         symbolExternalModule = getExternalModuleContainer(c, d);
         if (symbolExternalModule !== undefined)
             break;
@@ -109,7 +109,7 @@ function isAnySymbolAccessible(c, symbols, enclosingDeclaration, initialSymbol,
     return undefined;
 }
 export function hasNonGlobalAugmentationExternalModuleDeclaration(symbol) {
-    for (const d of symbol.declarations)
+    for (const d of getDeclarations(symbol))
         if (hasNonGlobalAugmentationExternalModuleSymbol(d))
             return true;
     return false;
@@ -128,18 +128,22 @@ function isModuleWithStringLiteralName(node) {
 export function getQualifiedLeftMeaning(rightMeaning) {
     return rightMeaning === 111551 /* SymbolFlags.Value */ ? 111551 /* SymbolFlags.Value */ : 1920 /* SymbolFlags.Namespace */;
 }
+/** The merged symbol `symbol` resolves to through aliases. */
+function getResolvedTarget(c, symbol) {
+    const resolved = resolveSymbol(c, getMergedSymbol(c, symbol));
+    return resolved !== undefined ? getMergedSymbol(c, resolved) : undefined;
+}
 /** `s1` if both symbols resolve to the same symbol, else undefined. */
 export function getSymbolIfSameReference(c, s1, s2) {
-    const r1 = resolveSymbol(c, getMergedSymbol(c, s1));
-    const r2 = resolveSymbol(c, getMergedSymbol(c, s2));
-    if (r1 !== undefined && r2 !== undefined && getMergedSymbol(c, r1) === getMergedSymbol(c, r2))
+    const r1 = getResolvedTarget(c, s1);
+    if (r1 !== undefined && r1 === getResolvedTarget(c, s2))
         return s1;
     return undefined;
 }
 // ---- Containers
 function getWithAlternativeContainers(c, container, symbol, enclosingDeclaration, meaning) {
     const additionalContainers = [];
-    for (const d of container.declarations) {
+    for (const d of getDeclarations(container)) {
         const fileSymbol = getFileSymbolIfFileSymbolExportEqualsContainer(c, d, container);
         if (fileSymbol !== undefined)
             additionalContainers.push(fileSymbol);
@@ -225,24 +229,117 @@ function getAlternativeContainingModules(c, symbol, enclosingDeclaration) {
     const cached = cache.containers.get(symbolId);
     if (cached !== undefined)
         return cached;
-    // Search every module; expensive, but independent of the location.
+    // Search every module; independent of the location.
+    const containers = getExternalModuleContainers(c, symbol);
+    cache.containers.set(symbolId, containers);
+    return containers;
+}
+/** The modules that export `symbol`, and its parent module, in program order. */
+function getExternalModuleContainers(c, symbol) {
+    const cache = caches(c);
+    if (cache.externalModuleContainers === undefined)
+        buildExternalModuleContainerIndex(c);
+    const index = cache.externalModuleContainers;
+    // Re-entered from an alias resolved while building the index, or too many files to index.
+    if (!index.complete)
+        return scanExternalModuleContainers(c, symbol);
+    // The parent module contains the symbol even when the symbol is absent from its exports.
+    const parent = getParentOfSymbol(c, symbol);
+    let parentIndex = externalModuleFileIndex(c, parent);
+    const result = [];
+    const target = getResolvedTarget(c, symbol);
+    if (target !== undefined) {
+        const keys = index.keys;
+        const first = getSymbolId(target) * fileIndexScale;
+        let low = 0;
+        let high = keys.length;
+        while (low < high) {
+            const mid = (low + high) >>> 1;
+            if (keys[mid] < first)
+                low = mid + 1;
+            else
+                high = mid;
+        }
+        for (let i = low; i < keys.length && keys[i] < first + fileIndexScale; i++) {
+            const fileIndex = keys[i] - first;
+            if (parentIndex >= 0 && parentIndex <= fileIndex) {
+                if (parentIndex < fileIndex)
+                    result.push(parent);
+                parentIndex = -1;
+            }
+            // `as`: scriptc passes an element of a subclass array only as that class.
+            result.push(getSymbolOfDeclaration(c, c.files[fileIndex]));
+        }
+    }
+    if (parentIndex >= 0)
+        result.push(parent);
+    return result;
+}
+/** The position in `Checker.files` of the external module `symbol`, or -1 for any other symbol. */
+function externalModuleFileIndex(c, symbol) {
+    if (symbol === undefined || (symbol.flags & 512 /* SymbolFlags.ValueModule */) === 0)
+        return -1;
+    for (const declaration of getDeclarations(symbol)) {
+        if (declaration.kind !== 307 /* SyntaxKind.SourceFile */)
+            continue;
+        const file = declaration;
+        if (isExternalModule(file) && getSymbolOfDeclaration(c, declaration) === symbol)
+            return c.fileIndex.get(file) ?? -1;
+    }
+    return -1;
+}
+function buildExternalModuleContainerIndex(c) {
+    const index = new ExternalModuleContainerIndex();
+    caches(c).externalModuleContainers = index;
+    if (c.files.length > fileIndexScale)
+        return;
+    const keys = [];
+    for (let fileIndex = 0; fileIndex < c.files.length; fileIndex++) {
+        const file = c.files[fileIndex];
+        if (!isExternalModule(file))
+            continue;
+        // `as`: scriptc passes an element of a subclass array only as that class.
+        const container = getSymbolOfDeclaration(c, file);
+        if (container === undefined)
+            continue;
+        for (const exported of getExportsOfSymbol(c, container).values()) {
+            const target = getResolvedTarget(c, exported);
+            if (target !== undefined)
+                keys.push(getSymbolId(target) * fileIndexScale + fileIndex);
+        }
+        const exportEquals = container.exports?.get("export=" /* InternalSymbolName.ExportEquals */);
+        const target = exportEquals !== undefined ? getResolvedTarget(c, exportEquals) : undefined;
+        if (target !== undefined)
+            keys.push(getSymbolId(target) * fileIndexScale + fileIndex);
+    }
+    keys.sort((a, b) => a - b);
+    // A module that exports a symbol under several names gives it one key.
+    let kept = 0;
+    for (let i = 0; i < keys.length; i++)
+        if (kept === 0 || keys[i] !== keys[kept - 1])
+            keys[kept++] = keys[i];
+    // An exact-size copy: each checker keeps its own index for the rest of the compilation.
+    index.keys = keys.slice(0, kept);
+    index.complete = true;
+}
+/** The modules that export `symbol`, found by checking every module. */
+function scanExternalModuleContainers(c, symbol) {
+    const containers = [];
     for (const file of c.host.getSourceFiles()) {
         if (!isExternalModule(file))
             continue;
         // `as`: scriptc passes a for-of element of a subclass array only as that class.
-        const fileSymbol = getSymbolOfDeclaration(c, file);
-        if (fileSymbol === undefined || getAliasForSymbolInContainer(c, fileSymbol, symbol) === undefined)
-            continue;
-        results.push(fileSymbol);
+        const container = getSymbolOfDeclaration(c, file);
+        if (container !== undefined && getAliasForSymbolInContainer(c, container, symbol) !== undefined)
+            containers.push(container);
     }
-    cache.containers.set(symbolId, results);
-    return results;
+    return containers;
 }
 /** The variable `var a = { x: 1 }` declares, for the anonymous `__object` symbol of its literal. */
 function getVariableDeclarationOfObjectLiteral(c, symbol, meaning) {
-    if ((meaning & 111551 /* SymbolFlags.Value */) === 0 || symbol.declarations.length === 0)
+    if ((meaning & 111551 /* SymbolFlags.Value */) === 0 || declarationCount(symbol) === 0)
         return undefined;
-    const firstDecl = symbol.declarations[0];
+    const firstDecl = symbol.declaration;
     const parent = firstDecl.parent;
     if (parent === undefined || !(parent instanceof VariableDeclaration))
         return undefined;
@@ -282,7 +379,7 @@ export function getContainersOfSymbol(c, symbol, enclosingDeclaration, meaning)
         if (s !== undefined && candidates.indexOf(s) < 0)
             candidates.push(s);
     };
-    for (const d of symbol.declarations) {
+    for (const d of getDeclarations(symbol)) {
         const parent = d.parent;
         if (!isAmbientModule(d) && parent !== undefined) {
             // A direct child of a module.
@@ -448,7 +545,7 @@ class ChainSearch {
                 (this.useOnlyExternalAliasing && !hasExternalModuleImportEqualsDeclaration(fromTable)) ||
                 (isLocalNameLookup && hasNamespaceReexportDeclaration(fromTable)) ||
                 // Exports are in scope, but export specifiers aren't.
-                (!ignoreQualification && fromTable.declarations.some((d) => d.kind === 282 /* SyntaxKind.ExportSpecifier */)))
+                (!ignoreQualification && getDeclarations(fromTable).some((d) => d.kind === 282 /* SyntaxKind.ExportSpecifier */)))
                 continue;
             const resolved = resolveAlias(c, fromTable);
             const candidate = this.candidateListForSymbol(fromTable, resolved, ignoreQualification);
@@ -542,10 +639,10 @@ function compareSymbolChains(c, a, b) {
     return 0;
 }
 function isUMDExportSymbol(symbol) {
-    return symbol.declarations.length > 0 && symbol.declarations[0].kind === 271 /* SyntaxKind.NamespaceExportDeclaration */;
+    return declarationCount(symbol) > 0 && symbol.declaration.kind === 271 /* SyntaxKind.NamespaceExportDeclaration */;
 }
 function hasNamespaceReexportDeclaration(symbol) {
-    for (const d of symbol.declarations)
+    for (const d of getDeclarations(symbol))
         if (isNamespaceReexportDeclaration(d))
             return true;
     return false;
@@ -556,7 +653,7 @@ function isNamespaceReexportDeclaration(node) {
         node.parent.moduleSpecifier !== undefined);
 }
 function hasExternalModuleImportEqualsDeclaration(symbol) {
-    for (const d of symbol.declarations)
+    for (const d of getDeclarations(symbol))
         if (isExternalModuleImportEqualsDeclaration(d))
             return true;
     return false;
@@ -576,7 +673,7 @@ export function needsQualification(c, symbol, enclosingDeclaration, meaning) {
             return true;
         // Qualify if the symbol of this name has the meaning sought.
         const shouldResolveAlias = (fromTable.flags & 2097152 /* SymbolFlags.Alias */) !== 0 &&
-            !fromTable.declarations.some((d) => d.kind === 282 /* SyntaxKind.ExportSpecifier */);
+            !getDeclarations(fromTable).some((d) => d.kind === 282 /* SyntaxKind.ExportSpecifier */);
         if (shouldResolveAlias)
             fromTable = resolveAlias(c, fromTable);
         const flags = shouldResolveAlias ? getSymbolFlags(c, fromTable) : fromTable.flags;
@@ -589,9 +686,9 @@ export function needsQualification(c, symbol, enclosingDeclaration, meaning) {
     return qualify;
 }
 function isPropertyOrMethodDeclarationSymbol(symbol) {
-    if (symbol.declarations.length === 0)
+    if (declarationCount(symbol) === 0)
         return false;
-    for (const declaration of symbol.declarations) {
+    for (const declaration of getDeclarations(symbol)) {
         switch (declaration.kind) {
             case 173 /* SyntaxKind.PropertyDeclaration */:
             case 175 /* SyntaxKind.MethodDeclaration */:
@@ -834,7 +931,7 @@ export function hasVisibleDeclarations(c, symbol, shouldComputeAliasesToMakeVisi
         if (aliases.indexOf(statement) < 0)
             aliases.push(statement);
     };
-    for (const declaration of symbol.declarations) {
+    for (const declaration of getDeclarations(symbol)) {
         if (declaration.kind === 79 /* SyntaxKind.Identifier */ || isDeclarationVisible(c, declaration))
             continue;
         // Unexported imports can name types if their parent is visible.

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

@@ -132,19 +132,46 @@ export declare class SymbolRareFields implements ProgramLifetime {
     members: SymbolTable | undefined;
     exports: SymbolTable | undefined;
     exportSymbol: Symbol | undefined;
+    /** All declarations of a symbol that has more than one (`getDeclarations`). */
+    declarations: Node[] | undefined;
+    /** The value declaration where it is not the first declaration (`Symbol.valueDeclaration`). */
+    valueDeclaration: Node | undefined;
 }
 export declare class Symbol implements ProgramLifetime {
     flags: SymbolFlags;
-    checkFlags: CheckFlags;
+    /** The check flags, and `valueDeclarationIsFirst`. */
+    private bits;
     readonly name: string;
-    declarations: Node[];
-    valueDeclaration: Node | undefined;
+    /**
+     * The first declaration. A symbol with more keeps all of them in its rare fields; read them with
+     * `declarationCount`, `declarationAt` and `getDeclarations`. Written only through `setFirst`,
+     * which keeps the value declaration.
+     */
+    declaration: Node | undefined;
     parent: Symbol | undefined;
     private rareFields;
     /** Assigned on first use by `getSymbolId`, or at creation while threads share the program; 0 until then. */
     id: number;
     constructor(flags: SymbolFlags, name: string);
+    get checkFlags(): CheckFlags;
+    set checkFlags(flags: CheckFlags);
+    /** Makes `node` the first declaration, keeping the value declaration. */
+    setFirst(node: Node | undefined): void;
+    /**
+     * The declaration of the symbol's value. Almost always the first declaration, which a bit of `bits`
+     * says; any other is kept in the rare fields.
+     */
+    get valueDeclaration(): Node | undefined;
+    set valueDeclaration(node: Node | undefined);
     private rareFieldsOrNew;
+    /**
+     * The declarations, for tsc-ts/api's `Symbol.declarations`. The compiler reads `declaration`,
+     * `declarationCount` and `declarationAt`: for a single declaration this builds a list on each read.
+     */
+    get declarations(): readonly Node[];
+    /** All declarations where there are more than one, else undefined. */
+    get moreDeclarations(): Node[] | undefined;
+    set moreDeclarations(value: Node[] | undefined);
     get members(): SymbolTable | undefined;
     set members(value: SymbolTable | undefined);
     get exports(): SymbolTable | undefined;
@@ -182,6 +209,21 @@ export declare function lastSymbolIdValue(): number;
 export declare function reserveSymbolIds(last: number): void;
 /** Appends `node` to the declarations of `symbol`. */
 export declare function addDeclaration(symbol: Symbol, node: Node): void;
+/** The number of declarations of `symbol`. */
+export declare function declarationCount(symbol: Symbol): number;
+/** The declaration of `symbol` at `index`, which is below `declarationCount(symbol)`. */
+export declare function declarationAt(symbol: Symbol, index: number): Node;
+/**
+ * The declarations of `symbol`, in order. A symbol with one declaration gets a new list each call;
+ * hot paths read `declaration`, `declarationCount` and `declarationAt` instead.
+ */
+export declare function getDeclarations(symbol: Symbol): readonly Node[];
+/** Whether `node` is a declaration of `symbol`. */
+export declare function hasDeclaration(symbol: Symbol, node: Node): boolean;
+/** Gives `target` the declarations of `source`; a list of several is shared, as the list was before. */
+export declare function copyDeclarations(target: Symbol, source: Symbol): void;
+/** Replaces the declarations of `symbol` with `declarations`, which it keeps when they are more than one. */
+export declare function setDeclarations(symbol: Symbol, declarations: readonly Node[]): void;
 /** A program-wide id, assigned to each symbol when first requested. */
 export declare function getSymbolId(symbol: Symbol): number;
 /** The exports table of `symbol`, created if missing. */

package/dist/api/compiler/symbol.js

@@ -3,27 +3,74 @@ export class SymbolRareFields {
     members = undefined;
     exports = undefined;
     exportSymbol = undefined;
+    /** All declarations of a symbol that has more than one (`getDeclarations`). */
+    declarations = undefined;
+    /** The value declaration where it is not the first declaration (`Symbol.valueDeclaration`). */
+    valueDeclaration = undefined;
 }
+/** In `Symbol.bits`, above the check flags: the value declaration is the first declaration. */
+const valueDeclarationIsFirst = 1 << 30;
 export class Symbol {
     flags;
-    checkFlags;
+    /** The check flags, and `valueDeclarationIsFirst`. */
+    bits;
     name;
-    declarations;
-    valueDeclaration;
+    /**
+     * The first declaration. A symbol with more keeps all of them in its rare fields; read them with
+     * `declarationCount`, `declarationAt` and `getDeclarations`. Written only through `setFirst`,
+     * which keeps the value declaration.
+     */
+    declaration;
     parent;
     rareFields;
     /** Assigned on first use by `getSymbolId`, or at creation while threads share the program; 0 until then. */
     id;
     constructor(flags, name) {
         this.flags = flags;
-        this.checkFlags = 0 /* CheckFlags.None */;
+        this.bits = 0;
         this.name = name;
-        this.declarations = noDeclarations;
-        this.valueDeclaration = undefined;
+        this.declaration = undefined;
         this.parent = undefined;
         this.rareFields = undefined;
         this.id = idsAtCreation ? takeSymbolId() : 0;
     }
+    get checkFlags() {
+        return (this.bits & ~valueDeclarationIsFirst);
+    }
+    set checkFlags(flags) {
+        this.bits = (this.bits & valueDeclarationIsFirst) | flags;
+    }
+    /** Makes `node` the first declaration, keeping the value declaration. */
+    setFirst(node) {
+        if ((this.bits & valueDeclarationIsFirst) !== 0 && node !== this.declaration) {
+            // The value declaration stays what it was.
+            this.rareFieldsOrNew().valueDeclaration = this.declaration;
+            this.bits &= ~valueDeclarationIsFirst;
+        }
+        this.declaration = node;
+    }
+    /**
+     * The declaration of the symbol's value. Almost always the first declaration, which a bit of `bits`
+     * says; any other is kept in the rare fields.
+     */
+    get valueDeclaration() {
+        if ((this.bits & valueDeclarationIsFirst) !== 0)
+            return this.declaration;
+        const group = this.rareFields;
+        return group === undefined ? undefined : group.valueDeclaration;
+    }
+    set valueDeclaration(node) {
+        const group = this.rareFields;
+        if (node !== undefined && node === this.declaration) {
+            this.bits |= valueDeclarationIsFirst;
+            if (group !== undefined)
+                group.valueDeclaration = undefined;
+            return;
+        }
+        this.bits &= ~valueDeclarationIsFirst;
+        if (node !== undefined || group !== undefined)
+            this.rareFieldsOrNew().valueDeclaration = node;
+    }
     rareFieldsOrNew() {
         let group = this.rareFields;
         if (group === undefined) {
@@ -32,6 +79,23 @@ export class Symbol {
         }
         return group;
     }
+    /**
+     * The declarations, for tsc-ts/api's `Symbol.declarations`. The compiler reads `declaration`,
+     * `declarationCount` and `declarationAt`: for a single declaration this builds a list on each read.
+     */
+    get declarations() {
+        return getDeclarations(this);
+    }
+    /** All declarations where there are more than one, else undefined. */
+    get moreDeclarations() {
+        const group = this.rareFields;
+        return group === undefined ? undefined : group.declarations;
+    }
+    set moreDeclarations(value) {
+        if (value === undefined && this.rareFields === undefined)
+            return;
+        this.rareFieldsOrNew().declarations = value;
+    }
     get members() {
         const group = this.rareFields;
         return group === undefined ? undefined : group.members;
@@ -156,11 +220,58 @@ export function reserveSymbolIds(last) {
 const noDeclarations = [];
 /** Appends `node` to the declarations of `symbol`. */
 export function addDeclaration(symbol, node) {
-    const declarations = symbol.declarations;
-    if (declarations.length === 0)
-        symbol.declarations = [node];
+    const first = symbol.declaration;
+    if (first === undefined) {
+        symbol.setFirst(node);
+        return;
+    }
+    const more = symbol.moreDeclarations;
+    if (more !== undefined)
+        more.push(node);
     else
-        declarations.push(node);
+        symbol.moreDeclarations = [first, node];
+}
+/** The number of declarations of `symbol`. */
+export function declarationCount(symbol) {
+    if (symbol.declaration === undefined)
+        return 0;
+    const more = symbol.moreDeclarations;
+    return more !== undefined ? more.length : 1;
+}
+/** The declaration of `symbol` at `index`, which is below `declarationCount(symbol)`. */
+export function declarationAt(symbol, index) {
+    return index === 0 ? symbol.declaration : symbol.moreDeclarations[index];
+}
+/**
+ * The declarations of `symbol`, in order. A symbol with one declaration gets a new list each call;
+ * hot paths read `declaration`, `declarationCount` and `declarationAt` instead.
+ */
+export function getDeclarations(symbol) {
+    const first = symbol.declaration;
+    if (first === undefined)
+        return noDeclarations;
+    const more = symbol.moreDeclarations;
+    return more !== undefined ? more : [first];
+}
+/** Whether `node` is a declaration of `symbol`. */
+export function hasDeclaration(symbol, node) {
+    const first = symbol.declaration;
+    if (first === undefined)
+        return false;
+    if (first === node)
+        return true;
+    const more = symbol.moreDeclarations;
+    return more !== undefined && more.indexOf(node) >= 0;
+}
+/** Gives `target` the declarations of `source`; a list of several is shared, as the list was before. */
+export function copyDeclarations(target, source) {
+    target.setFirst(source.declaration);
+    target.moreDeclarations = source.moreDeclarations;
+}
+/** Replaces the declarations of `symbol` with `declarations`, which it keeps when they are more than one. */
+export function setDeclarations(symbol, declarations) {
+    symbol.setFirst(declarations.length !== 0 ? declarations[0] : undefined);
+    symbol.moreDeclarations = declarations.length > 1 ? declarations : undefined;
 }
 /**
  * The symbols of `table` by escaped name, with their ids assigned, as tsc-ts's public API types them: the map's

package/dist/api/compiler/transformers/alias-references.d.ts

@@ -1,7 +1,7 @@
 import { type Node, NodeVisitor, type SourceFile } from '../ast.js';
 import { type CompilerOptions } from '../options.js';
-import { type Symbol } from '../symbol.js';
 import { type ReferenceResolver } from './reference-resolver.js';
+import { type Symbol } from '../symbol.js';
 export declare class AliasReferences extends NodeVisitor {
     readonly options: CompilerOptions;
     readonly resolver: ReferenceResolver;

package/dist/api/compiler/transformers/alias-references.js

@@ -9,6 +9,7 @@ import { JsxEmit, getIsolatedModules, getStrictOptionValue, shouldPreserveConstE
 import { getDeclarationOfAliasSymbol } from './reference-resolver.js';
 import { getFirstConstructorWithBody, getRestParameterElementType, getSetAccessorValueParameter, nodeCanBeDecorated, } from './decorator-utilities.js';
 import { hasDecorators, hasSyntacticModifier } from './utilities.js';
+import { getDeclarations } from '../symbol.js';
 export class AliasReferences extends NodeVisitor {
     options;
     resolver;
@@ -149,7 +150,7 @@ export class AliasReferences extends NodeVisitor {
         if (symbol === undefined)
             return undefined;
         const kind = node.kind === 179 /* SyntaxKind.SetAccessor */ ? 178 /* SyntaxKind.GetAccessor */ : 179 /* SyntaxKind.SetAccessor */;
-        for (const declaration of symbol.declarations)
+        for (const declaration of getDeclarations(symbol))
             if (declaration.kind === kind)
                 return declaration;
         return undefined;