tsc-ts 0.0.5 → 0.0.6

package/src/compiler/relations.ts

@@ -13,7 +13,6 @@ import {
 import { getSymbolNameForPrivateIdentifier } from './binder.js';
 import { getCombinedModifierFlags } from './binder-utilities.js';
 import { Diagnostic, type DiagnosticMessage, Diagnostics, messageElidedInCompatibilityPyramid } from './diagnostics.js';
-import { CheckFlags, type Symbol, SymbolFlags, getSymbolId } from './symbol.js';
 import { SyntaxKind } from './syntax-kind.js';
 import { isContextSensitive } from './checker-functions.js';
 import { type Checker, createDiagnosticForNode } from './checker.js';
@@ -224,6 +223,7 @@ import {
   isNumericLiteralName,
   maybeTypeOfKind,
 } from './checker-utilities.js';
+import { CheckFlags, declarationCount, getDeclarations, getSymbolId, type Symbol, SymbolFlags } from './symbol.js';
 
 // ---- Results and caches
 
@@ -754,8 +754,8 @@ function isEnumTypeRelatedTo(c: Checker, source: Symbol, target: Symbol, reporte
       c.enumRelation.set(key, RelationComparisonResult.Failed);
       return false;
     }
-    const sourceDecl = sourceProperty.declarations.find((d) => d.kind === SyntaxKind.EnumMember);
-    const targetDecl = targetProperty.declarations.find((d) => d.kind === SyntaxKind.EnumMember);
+    const sourceDecl = getDeclarations(sourceProperty).find((d) => d.kind === SyntaxKind.EnumMember);
+    const targetDecl = getDeclarations(targetProperty).find((d) => d.kind === SyntaxKind.EnumMember);
     if (sourceDecl === undefined || targetDecl === undefined) continue;
     computeEnumMemberValues(c, sourceDecl.parent!);
     computeEnumMemberValues(c, targetDecl.parent!);
@@ -1375,8 +1375,8 @@ export class Relater extends TypeComparer {
             return true;
           }
           const objectLiteralDeclaration =
-            source.symbol !== undefined && source.symbol.declarations.length !== 0
-              ? source.symbol.declarations[0]!
+            source.symbol !== undefined && declarationCount(source.symbol) !== 0
+              ? source.symbol.declaration!
               : undefined;
           const valueDeclaration = prop.valueDeclaration;
           let suggestion: Symbol | undefined = undefined;
@@ -3037,9 +3037,9 @@ export class Relater extends TypeComparer {
         names[0],
         names[1],
       ]);
-      if (unmatchedProperty.declarations.length !== 0)
+      if (declarationCount(unmatchedProperty) !== 0)
         this.relatedInfo.push(
-          createDiagnosticForNode(unmatchedProperty.declarations[0]!, Diagnostics.X_0_is_declared_here, [propName]),
+          createDiagnosticForNode(unmatchedProperty.declaration!, Diagnostics.X_0_is_declared_here, [propName]),
         );
     } else if (this.tryElaborateArrayLikeErrors(source, target, false)) {
       const names = getTypeNamesForErrorDisplay(c, source, target);
@@ -3486,7 +3486,7 @@ export class Relater extends TypeComparer {
     if (
       (source.flags & TypeFlags.TypeParameter) !== 0 &&
       source.symbol !== undefined &&
-      source.symbol.declarations.length !== 0 &&
+      declarationCount(source.symbol) !== 0 &&
       getConstraintOfType(c, source) === undefined
     ) {
       const syntheticParam = cloneTypeParameter(c, source);
@@ -3494,7 +3494,7 @@ export class Relater extends TypeComparer {
       if (hasNonCircularBaseConstraint(c, syntheticParam)) {
         this.relatedInfo.push(
           createDiagnosticForNode(
-            source.symbol.declarations[0]!,
+            source.symbol.declaration!,
             Diagnostics.This_type_parameter_might_need_an_extends_0_constraint,
             [typeToString(c, target)],
           ),
@@ -4504,7 +4504,7 @@ import { getTypeAliasInstantiation } from './checker-type-nodes.js';
 
 export function getTypeParameterModifiers(tp: Type): ModifierFlags {
   let flags = 0;
-  if (tp.symbol !== undefined) for (const d of tp.symbol.declarations) flags |= getCombinedModifierFlags(d);
+  if (tp.symbol !== undefined) for (const d of getDeclarations(tp.symbol)) flags |= getCombinedModifierFlags(d);
   return flags & (ModifierFlags.In | ModifierFlags.Out | ModifierFlags.Const);
 }
 

package/src/compiler/symbol-accessibility.ts

@@ -35,7 +35,7 @@ import {
   isGlobalSourceFile,
   isModuleExportsAccessExpression,
 } from './binder-utilities.js';
-import { type Checker, SymbolAccessibilityCaches } from './checker.js';
+import { type Checker, 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';
@@ -52,7 +52,6 @@ import {
 import { getTypeOfSymbol } from './checker-symbol-types.js';
 import { compareSymbols } from './checker-type-factory.js';
 import { TypeFlags } from './checker-types.js';
-import { InternalSymbolName, type Symbol, SymbolFlags, type SymbolTable, getSymbolId } from './symbol.js';
 import { SyntaxKind } from './syntax-kind.js';
 import { SymbolAccessibility, SymbolAccessibilityResult, accessible } from './transformers/declarations-resolver.js';
 import {
@@ -63,6 +62,15 @@ import {
 } from './transformers/declarations-syntactic.js';
 import { isImplicitlyExportedJSDocDeclaration } from './binder-utilities.js';
 import { symbolToString } from './type-printer.js';
+import {
+  declarationCount,
+  getDeclarations,
+  getSymbolId,
+  InternalSymbolName,
+  type Symbol,
+  SymbolFlags,
+  type SymbolTable,
+} from './symbol.js';
 
 /** The kinds of symbol table, which with a node or symbol id name a table in a scope walk. */
 const enum TableKind {
@@ -157,7 +165,7 @@ function isSymbolAccessibleWorker(
   if (result !== undefined) return result;
   // A symbol not exported from its module, or from another module without an alias, can't be named.
   let symbolExternalModule: Symbol | undefined = undefined;
-  for (const d of symbol.declarations) {
+  for (const d of getDeclarations(symbol)) {
     symbolExternalModule = getExternalModuleContainer(c, d);
     if (symbolExternalModule !== undefined) break;
   }
@@ -230,7 +238,7 @@ function isAnySymbolAccessible(
 }
 
 export function hasNonGlobalAugmentationExternalModuleDeclaration(symbol: Symbol): boolean {
-  for (const d of symbol.declarations) if (hasNonGlobalAugmentationExternalModuleSymbol(d)) return true;
+  for (const d of getDeclarations(symbol)) if (hasNonGlobalAugmentationExternalModuleSymbol(d)) return true;
   return false;
 }
 
@@ -252,11 +260,16 @@ export function getQualifiedLeftMeaning(rightMeaning: SymbolFlags): SymbolFlags
   return rightMeaning === SymbolFlags.Value ? SymbolFlags.Value : SymbolFlags.Namespace;
 }
 
+/** The merged symbol `symbol` resolves to through aliases. */
+function getResolvedTarget(c: Checker, symbol: Symbol): Symbol | undefined {
+  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: Checker, s1: Symbol, s2: Symbol): Symbol | undefined {
-  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)) return s1;
+  const r1 = getResolvedTarget(c, s1);
+  if (r1 !== undefined && r1 === getResolvedTarget(c, s2)) return s1;
   return undefined;
 }
 
@@ -270,7 +283,7 @@ function getWithAlternativeContainers(
   meaning: SymbolFlags,
 ): Symbol[] {
   const additionalContainers: Symbol[] = [];
-  for (const d of container.declarations) {
+  for (const d of getDeclarations(container)) {
     const fileSymbol = getFileSymbolIfFileSymbolExportEqualsContainer(c, d, container);
     if (fileSymbol !== undefined) additionalContainers.push(fileSymbol);
   }
@@ -350,22 +363,104 @@ function getAlternativeContainingModules(c: Checker, symbol: Symbol, enclosingDe
   }
   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: Checker, symbol: Symbol): 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: Symbol[] = [];
+  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]! as Node)!);
+    }
+  }
+  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: Checker, symbol: Symbol | undefined): number {
+  if (symbol === undefined || (symbol.flags & SymbolFlags.ValueModule) === 0) return -1;
+  for (const declaration of getDeclarations(symbol)) {
+    if (declaration.kind !== SyntaxKind.SourceFile) continue;
+    const file = declaration as SourceFile;
+    if (isExternalModule(file) && getSymbolOfDeclaration(c, declaration) === symbol) return c.fileIndex.get(file) ?? -1;
+  }
+  return -1;
+}
+
+function buildExternalModuleContainerIndex(c: Checker): void {
+  const index = new ExternalModuleContainerIndex();
+  caches(c).externalModuleContainers = index;
+  if (c.files.length > fileIndexScale) return;
+  const keys: number[] = [];
+  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 as Node);
+    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(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: Checker, symbol: Symbol): Symbol[] {
+  const containers: Symbol[] = [];
   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 as Node);
-    if (fileSymbol === undefined || getAliasForSymbolInContainer(c, fileSymbol, symbol) === undefined) continue;
-    results.push(fileSymbol);
+    const container = getSymbolOfDeclaration(c, file as Node);
+    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: Checker, symbol: Symbol, meaning: SymbolFlags): Symbol | undefined {
-  if ((meaning & SymbolFlags.Value) === 0 || symbol.declarations.length === 0) return undefined;
-  const firstDecl = symbol.declarations[0]!;
+  if ((meaning & SymbolFlags.Value) === 0 || declarationCount(symbol) === 0) return undefined;
+  const firstDecl = symbol.declaration!;
   const parent = firstDecl.parent;
   if (parent === undefined || !(parent instanceof VariableDeclaration)) return undefined;
   if (
@@ -417,7 +512,7 @@ export function getContainersOfSymbol(
   const addCandidate = (s: Symbol | undefined): void => {
     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.
@@ -585,7 +680,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 === SyntaxKind.ExportSpecifier))
+        (!ignoreQualification && getDeclarations(fromTable).some((d) => d.kind === SyntaxKind.ExportSpecifier))
       )
         continue;
       const resolved = resolveAlias(c, fromTable);
@@ -701,11 +796,11 @@ function compareSymbolChains(c: Checker, a: Symbol[], b: Symbol[]): number {
 }
 
 function isUMDExportSymbol(symbol: Symbol): boolean {
-  return symbol.declarations.length > 0 && symbol.declarations[0].kind === SyntaxKind.NamespaceExportDeclaration;
+  return declarationCount(symbol) > 0 && symbol.declaration!.kind === SyntaxKind.NamespaceExportDeclaration;
 }
 
 function hasNamespaceReexportDeclaration(symbol: Symbol): boolean {
-  for (const d of symbol.declarations) if (isNamespaceReexportDeclaration(d)) return true;
+  for (const d of getDeclarations(symbol)) if (isNamespaceReexportDeclaration(d)) return true;
   return false;
 }
 
@@ -718,7 +813,7 @@ function isNamespaceReexportDeclaration(node: Node): boolean {
 }
 
 function hasExternalModuleImportEqualsDeclaration(symbol: Symbol): boolean {
-  for (const d of symbol.declarations) if (isExternalModuleImportEqualsDeclaration(d)) return true;
+  for (const d of getDeclarations(symbol)) if (isExternalModuleImportEqualsDeclaration(d)) return true;
   return false;
 }
 
@@ -742,7 +837,7 @@ export function needsQualification(
     // Qualify if the symbol of this name has the meaning sought.
     const shouldResolveAlias =
       (fromTable.flags & SymbolFlags.Alias) !== 0 &&
-      !fromTable.declarations.some((d) => d.kind === SyntaxKind.ExportSpecifier);
+      !getDeclarations(fromTable).some((d) => d.kind === SyntaxKind.ExportSpecifier);
     if (shouldResolveAlias) fromTable = resolveAlias(c, fromTable);
     const flags = shouldResolveAlias ? getSymbolFlags(c, fromTable) : fromTable.flags;
     if ((flags & meaning) !== 0) {
@@ -755,8 +850,8 @@ export function needsQualification(
 }
 
 function isPropertyOrMethodDeclarationSymbol(symbol: Symbol): boolean {
-  if (symbol.declarations.length === 0) return false;
-  for (const declaration of symbol.declarations) {
+  if (declarationCount(symbol) === 0) return false;
+  for (const declaration of getDeclarations(symbol)) {
     switch (declaration.kind) {
       case SyntaxKind.PropertyDeclaration:
       case SyntaxKind.MethodDeclaration:
@@ -1007,7 +1102,7 @@ export function hasVisibleDeclarations(
     markDeclarationVisible(c, declaration);
     if (aliases.indexOf(statement) < 0) aliases.push(statement);
   };
-  for (const declaration of symbol.declarations) {
+  for (const declaration of getDeclarations(symbol)) {
     if (declaration.kind === SyntaxKind.Identifier || isDeclarationVisible(c, declaration)) continue;
     // Unexported imports can name types if their parent is visible.
     const anyImport = getAnyImportSyntax(declaration);

package/src/compiler/symbol.ts

@@ -150,14 +150,26 @@ export class SymbolRareFields implements ProgramLifetime {
   members: SymbolTable | undefined = undefined;
   exports: SymbolTable | undefined = undefined;
   exportSymbol: Symbol | undefined = undefined;
+  /** All declarations of a symbol that has more than one (`getDeclarations`). */
+  declarations: Node[] | undefined = undefined;
+  /** The value declaration where it is not the first declaration (`Symbol.valueDeclaration`). */
+  valueDeclaration: Node | undefined = undefined;
 }
 
+/** In `Symbol.bits`, above the check flags: the value declaration is the first declaration. */
+const valueDeclarationIsFirst = 1 << 30;
+
 export class Symbol implements ProgramLifetime {
   flags: SymbolFlags;
-  checkFlags: CheckFlags;
+  /** The check flags, and `valueDeclarationIsFirst`. */
+  private bits: number;
   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: SymbolRareFields | undefined;
   /** Assigned on first use by `getSymbolId`, or at creation while threads share the program; 0 until then. */
@@ -165,15 +177,53 @@ export class Symbol implements ProgramLifetime {
 
   constructor(flags: SymbolFlags, name: string) {
     this.flags = flags;
-    this.checkFlags = 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(): CheckFlags {
+    return (this.bits & ~valueDeclarationIsFirst) as CheckFlags;
+  }
+
+  set checkFlags(flags: CheckFlags) {
+    this.bits = (this.bits & valueDeclarationIsFirst) | flags;
+  }
+
+  /** Makes `node` the first declaration, keeping the value declaration. */
+  setFirst(node: Node | undefined): void {
+    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(): Node | undefined {
+    if ((this.bits & valueDeclarationIsFirst) !== 0) return this.declaration;
+    const group = this.rareFields;
+    return group === undefined ? undefined : group.valueDeclaration;
+  }
+
+  set valueDeclaration(node: Node | undefined) {
+    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;
+  }
+
   private rareFieldsOrNew(): SymbolRareFields {
     let group = this.rareFields;
     if (group === undefined) {
@@ -183,6 +233,25 @@ export class Symbol implements ProgramLifetime {
     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(): readonly Node[] {
+    return getDeclarations(this);
+  }
+
+  /** All declarations where there are more than one, else undefined. */
+  get moreDeclarations(): Node[] | undefined {
+    const group = this.rareFields;
+    return group === undefined ? undefined : group.declarations;
+  }
+
+  set moreDeclarations(value: Node[] | undefined) {
+    if (value === undefined && this.rareFields === undefined) return;
+    this.rareFieldsOrNew().declarations = value;
+  }
+
   get members(): SymbolTable | undefined {
     const group = this.rareFields;
     return group === undefined ? undefined : group.members;
@@ -326,9 +395,58 @@ const noDeclarations: Node[] = [];
 
 /** Appends `node` to the declarations of `symbol`. */
 export function addDeclaration(symbol: Symbol, node: Node): void {
-  const declarations = symbol.declarations;
-  if (declarations.length === 0) symbol.declarations = [node];
-  else declarations.push(node);
+  const first = symbol.declaration;
+  if (first === undefined) {
+    symbol.setFirst(node);
+    return;
+  }
+  const more = symbol.moreDeclarations;
+  if (more !== undefined) more.push(node);
+  else symbol.moreDeclarations = [first, node];
+}
+
+/** The number of declarations of `symbol`. */
+export function declarationCount(symbol: Symbol): number {
+  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: Symbol, index: number): Node {
+  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: Symbol): readonly Node[] {
+  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: Symbol, node: Node): boolean {
+  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: Symbol, source: Symbol): void {
+  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: Symbol, declarations: readonly Node[]): void {
+  symbol.setFirst(declarations.length !== 0 ? declarations[0] : undefined);
+  symbol.moreDeclarations = declarations.length > 1 ? (declarations as Node[]) : undefined;
 }
 
 /**

package/src/compiler/transformers/alias-references.ts

@@ -46,7 +46,6 @@ import {
   getStrictOptionValue,
   shouldPreserveConstEnums,
 } from '../options.js';
-import { type Symbol, SymbolFlags } from '../symbol.js';
 import { SyntaxKind } from '../syntax-kind.js';
 import { getDeclarationOfAliasSymbol, type ReferenceResolver } from './reference-resolver.js';
 import {
@@ -56,6 +55,7 @@ import {
   nodeCanBeDecorated,
 } from './decorator-utilities.js';
 import { hasDecorators, hasSyntacticModifier } from './utilities.js';
+import { getDeclarations, type Symbol, SymbolFlags } from '../symbol.js';
 
 export class AliasReferences extends NodeVisitor {
   readonly options: CompilerOptions;
@@ -214,7 +214,7 @@ export class AliasReferences extends NodeVisitor {
     const symbol = this.resolver.getSymbolOfDeclaration(node);
     if (symbol === undefined) return undefined;
     const kind = node.kind === SyntaxKind.SetAccessor ? SyntaxKind.GetAccessor : SyntaxKind.SetAccessor;
-    for (const declaration of symbol.declarations) if (declaration.kind === kind) return declaration;
+    for (const declaration of getDeclarations(symbol)) if (declaration.kind === kind) return declaration;
     return undefined;
   }
 

package/src/compiler/transformers/declarations-diagnostics.ts

@@ -30,6 +30,7 @@ import { isStatement } from '../printer/utilities.js';
 import { SyntaxKind } from '../syntax-kind.js';
 import { isParameterPropertyDeclaration } from './utilities.js';
 import { SymbolAccessibility, type SymbolAccessibilityResult } from './declarations-resolver.js';
+import { getDeclarations } from '../symbol.js';
 
 export function createDiagnosticForNode(node: Node, message: DiagnosticMessage, args: readonly string[]): Diagnostic {
   const file = getSourceFileOfNode(node);
@@ -816,7 +817,7 @@ export function getAllAccessorDeclarations(accessor: Node): AllAccessorDeclarati
   let other: Node | undefined = undefined;
   const symbol = getSymbol(accessor);
   if (symbol !== undefined)
-    for (const declaration of symbol.declarations)
+    for (const declaration of getDeclarations(symbol))
       if (declaration.kind === otherKind) {
         other = declaration;
         break;

package/src/compiler/transformers/declarations-pseudo.ts

@@ -37,9 +37,9 @@ import {
 import { isFunctionLike, nodeIsMissing } from '../ast-utilities.js';
 import { getCombinedNodeFlags, hasSyntacticModifier, isIdentifierNamed } from '../binder-utilities.js';
 import type { NameResolver } from '../name-resolver.js';
-import { type Symbol, SymbolFlags } from '../symbol.js';
 import { SyntaxKind } from '../syntax-kind.js';
 import { getAllAccessorDeclarations } from './declarations-diagnostics.js';
+import { declarationCount, getDeclarations, type Symbol, SymbolFlags } from '../symbol.js';
 
 export const enum PseudoTypeKind {
   /** The type an annotation denotes. */
@@ -359,7 +359,7 @@ export class PseudoChecker {
     // A property declared more than once has the type of its first declaration; only the checker
     // knows which, so the type is still written from this one but counted as uncertain.
     const symbol = getSymbol(node);
-    if (symbol !== undefined && symbol.declarations.length > 1) this.uncertain++;
+    if (symbol !== undefined && declarationCount(symbol) > 1) this.uncertain++;
     if (node instanceof PropertyDeclaration) {
       const initializer = node.initializer;
       if (initializer !== undefined && !isContextuallyTyped(node)) {
@@ -388,7 +388,10 @@ export class PseudoChecker {
     const initializer = declaration.initializer;
     // As tsgo, the file's own declarations; merged ones are left to the checker's type comparison.
     const symbol = declaration.symbol;
-    if (initializer !== undefined && (symbol === undefined || countVariableDeclarations(symbol.declarations) === 1)) {
+    if (
+      initializer !== undefined &&
+      (symbol === undefined || countVariableDeclarations(getDeclarations(symbol)) === 1)
+    ) {
       if (!isContextuallyTyped(declaration)) {
         // Const template literals may become literal types, so they aren't inferred.
         if (
@@ -695,7 +698,7 @@ function accessorAnnotation(node: Node): Node | undefined {
   return undefined;
 }
 
-function countVariableDeclarations(declarations: Node[]): number {
+function countVariableDeclarations(declarations: readonly Node[]): number {
   if (declarations.length === 1) return 1;
   let count = 0;
   for (const declaration of declarations) if (declaration.kind === SyntaxKind.VariableDeclaration) count++;