tsc-ts 0.0.5 → 0.0.6

package/src/compiler/instantiation.ts

@@ -15,7 +15,6 @@ import {
   TypeQueryNode,
 } from './ast.js';
 import { Diagnostics } from './diagnostics.js';
-import { CheckFlags, type Symbol, SymbolFlags, getSymbolId } from './symbol.js';
 import { SyntaxKind } from './syntax-kind.js';
 import type { Checker, VarianceReporting } from './checker.js';
 import {
@@ -79,6 +78,15 @@ import {
 import { getConstraintDeclaration } from './checker-declared-types.js';
 import { isTypeAssignableTo } from './relations.js';
 import { getFirstIdentifier } from './checker-symbols.js';
+import {
+  CheckFlags,
+  copyDeclarations,
+  declarationCount,
+  getDeclarations,
+  getSymbolId,
+  type Symbol,
+  SymbolFlags,
+} from './symbol.js';
 
 // ---- Mappers that need the checker
 
@@ -181,8 +189,18 @@ export function instantiateTypeWithAlias(
   alias: TypeAlias | undefined,
 ): Type {
   if (mapper === undefined) return type;
-  // Aliases with type arguments may be copied with new arguments even when the type itself has no type variables.
-  if (!couldContainTypeVariables(c, type) && !aliasCouldContainTypeVariables(c, type)) return type;
+  // `couldContainTypeVariables`, answered here when the type's own flags decide it. Aliases with type
+  // arguments may be copied with new arguments even when the type itself has no type variables.
+  let could: boolean;
+  if ((type.flags & TypeFlags.StructuredOrInstantiable) === 0) could = false;
+  else {
+    const objectFlags = type.objectFlags;
+    could =
+      (objectFlags & ObjectFlags.CouldContainTypeVariablesComputed) !== 0
+        ? (objectFlags & ObjectFlags.CouldContainTypeVariables) !== 0
+        : couldContainTypeVariables(c, type);
+  }
+  if (!could && (type.alias === undefined || !aliasCouldContainTypeVariables(c, type))) return type;
   if (c.instantiationDepth === 100 || c.instantiationCount >= 5000000) {
     // Probably infinitely expanding generic types; stop with the error type.
     c.error(c.currentNode, Diagnostics.Type_instantiation_is_excessively_deep_and_possibly_infinite);
@@ -292,7 +310,7 @@ export function couldContainTypeVariables(c: Checker, type: Type): boolean {
               SymbolFlags.Class |
               SymbolFlags.TypeLiteral |
               SymbolFlags.ObjectLiteral)) !==
-            0 && type.symbol.declarations.length !== 0;
+            0 && declarationCount(type.symbol) !== 0;
       }
       if (!result)
         result =
@@ -324,7 +342,7 @@ function isNonGenericTopLevelType(type: Type): boolean {
   const alias = type.alias;
   if (alias === undefined || alias.typeArguments.length !== 0) return false;
   let declaration: Node | undefined;
-  for (const d of alias.symbol.declarations)
+  for (const d of getDeclarations(alias.symbol))
     if (d.kind === SyntaxKind.TypeAliasDeclaration || d.kind === SyntaxKind.JSTypeAliasDeclaration) {
       declaration = d;
       break;
@@ -429,11 +447,12 @@ function getObjectTypeInstantiation(
   mapper: TypeMapper,
   alias: TypeAlias | undefined,
 ): Type {
+  if ((type.objectFlags & ObjectFlags.Reference) === 0 && c.withoutOuterTypeParameters.get(type.id) !== 0) return type;
   let declaration: Node;
   if ((type.objectFlags & ObjectFlags.Reference) !== 0) declaration = (type as TypeReference).node!;
   else if ((type.objectFlags & ObjectFlags.InstantiationExpressionType) !== 0)
     declaration = (type as InstantiationExpressionType).node!;
-  else declaration = type.symbol!.declarations[0]!;
+  else declaration = type.symbol!.declaration!;
   const links = c.nodeLinks(declaration);
   let target: ObjectType;
   if ((type.objectFlags & ObjectFlags.Reference) !== 0) target = c.resolvedTypes.get(declaration.id) as ObjectType;
@@ -451,7 +470,7 @@ function getObjectTypeInstantiation(
       } else if ((target.symbol!.flags & (SymbolFlags.Method | SymbolFlags.TypeLiteral)) !== 0) {
         const referenced: Type[] = [];
         for (const tp of typeParameters) {
-          for (const d of type.symbol!.declarations) {
+          for (const d of getDeclarations(type.symbol!)) {
             if (isTypeParameterPossiblyReferenced(c, tp, d)) {
               referenced.push(tp);
               break;
@@ -463,14 +482,25 @@ function getObjectTypeInstantiation(
     }
     links.outerTypeParameters = typeParameters;
   }
-  if (typeParameters.length === 0) return type;
-  const combinedMapper = combineTypeMappers(c, type.mapper, mapper);
-  const typeArguments: Type[] = [];
-  for (const tp of typeParameters) typeArguments.push(combinedMapper.map(tp));
+  if (typeParameters.length === 0) {
+    if ((type.objectFlags & ObjectFlags.Reference) === 0) c.withoutOuterTypeParameters.set(type.id, 1);
+    return type;
+  }
+  // The type arguments, mapped as `combineTypeMappers(c, type.mapper, mapper)` maps them, into a
+  // list of the checker's that is copied only when the instantiation is new.
+  const typeMapper = type.mapper;
+  const mapped = c.freeTypeLists.pop() ?? [];
+  for (const tp of typeParameters) {
+    if (typeMapper === undefined) mapped.push(mapper.map(tp));
+    else {
+      const t1 = typeMapper.map(tp);
+      mapped.push(t1 !== tp ? instantiateType(c, t1, mapper) : mapper.map(tp));
+    }
+  }
   const newAlias = alias ?? instantiateTypeAlias(c, type.alias, mapper);
   const singleSignature = (type.objectFlags & ObjectFlags.SingleSignatureType) !== 0;
   const tag = singleSignature ? 1 : 0;
-  const hash = typeListHash(typeArguments, newAlias, tag);
+  const hash = typeListHash(mapped, newAlias, tag);
   const generic = sideOf(c, target);
   let instantiations = generic.instantiations;
   if (instantiations === undefined) {
@@ -478,39 +508,47 @@ function getObjectTypeInstantiation(
     instantiations.set(typeListHash(typeParameters, target.alias, 0), typeParameters, target.alias, 0, target);
     generic.instantiations = instantiations;
   }
-  let result = instantiations.get(hash, typeArguments, newAlias, tag);
-  if (result === undefined) {
-    let newMapper = newTypeMapper(typeParameters, typeArguments);
-    if ((target.objectFlags & ObjectFlags.SingleSignatureType) !== 0)
-      newMapper = combineTypeMappers(c, newMapper, mapper);
-    if ((target.objectFlags & ObjectFlags.Reference) !== 0)
-      result = createDeferredTypeReference(
-        c,
-        (type as TypeReference).target!,
-        (type as TypeReference).node!,
-        newMapper,
-        newAlias,
-      );
-    else if ((target.objectFlags & ObjectFlags.Mapped) !== 0)
-      result = instantiateMappedType(c, target as MappedType, newMapper, newAlias);
-    else result = instantiateAnonymousType(c, target, newMapper, newAlias);
-    instantiations.set(hash, typeArguments, newAlias, tag, result);
-    if (
-      (result.flags & TypeFlags.ObjectFlagsType) !== 0 &&
-      (lazyObjectFlags(c, result) & ObjectFlags.CouldContainTypeVariablesComputed) === 0
-    ) {
-      // Type variable containment follows from the type arguments.
-      let couldContain = false;
-      for (const t of typeArguments)
-        if (couldContainTypeVariables(c, t)) {
-          couldContain = true;
-          break;
-        }
-      if ((result.objectFlags & (ObjectFlags.Mapped | ObjectFlags.Anonymous | ObjectFlags.Reference)) !== 0)
-        sideOf(c, result).objectFlags |=
-          ObjectFlags.CouldContainTypeVariablesComputed | (couldContain ? ObjectFlags.CouldContainTypeVariables : 0);
-      else if (!couldContain) sideOf(c, result).objectFlags |= ObjectFlags.CouldContainTypeVariablesComputed;
-    }
+  const cached = instantiations.get(hash, mapped, newAlias, tag);
+  if (cached !== undefined) {
+    mapped.length = 0;
+    c.freeTypeLists.push(mapped);
+    return cached;
+  }
+  // The cache and the instantiation's mapper keep the type arguments.
+  const typeArguments = c.typeLists.intern(typeListHash(mapped, undefined, 0), mapped.slice());
+  mapped.length = 0;
+  c.freeTypeLists.push(mapped);
+  let result: Type;
+  let newMapper = newTypeMapper(typeParameters, typeArguments);
+  if ((target.objectFlags & ObjectFlags.SingleSignatureType) !== 0)
+    newMapper = combineTypeMappers(c, newMapper, mapper);
+  if ((target.objectFlags & ObjectFlags.Reference) !== 0)
+    result = createDeferredTypeReference(
+      c,
+      (type as TypeReference).target!,
+      (type as TypeReference).node!,
+      newMapper,
+      newAlias,
+    );
+  else if ((target.objectFlags & ObjectFlags.Mapped) !== 0)
+    result = instantiateMappedType(c, target as MappedType, newMapper, newAlias);
+  else result = instantiateAnonymousType(c, target, newMapper, newAlias);
+  instantiations.set(hash, typeArguments, newAlias, tag, result);
+  if (
+    (result.flags & TypeFlags.ObjectFlagsType) !== 0 &&
+    (lazyObjectFlags(c, result) & ObjectFlags.CouldContainTypeVariablesComputed) === 0
+  ) {
+    // Type variable containment follows from the type arguments.
+    let couldContain = false;
+    for (const t of typeArguments)
+      if (couldContainTypeVariables(c, t)) {
+        couldContain = true;
+        break;
+      }
+    if ((result.objectFlags & (ObjectFlags.Mapped | ObjectFlags.Anonymous | ObjectFlags.Reference)) !== 0)
+      sideOf(c, result).objectFlags |=
+        ObjectFlags.CouldContainTypeVariablesComputed | (couldContain ? ObjectFlags.CouldContainTypeVariables : 0);
+    else if (!couldContain) sideOf(c, result).objectFlags |= ObjectFlags.CouldContainTypeVariablesComputed;
   }
   return result;
 }
@@ -551,12 +589,12 @@ class ReferenceFinder extends NodeVisitor {
           !(firstIdentifier.kind === SyntaxKind.Identifier && firstIdentifier.text === 'this')
         ) {
           const symbol = getResolvedSymbolOfIdentifier(this.c, firstIdentifier);
-          const tpDeclaration = tp.symbol!.declarations[0]!;
+          const tpDeclaration = tp.symbol!.declaration!;
           let scope: Node | undefined;
           if (tpDeclaration.kind === SyntaxKind.TypeParameter) scope = tpDeclaration.parent;
           else if (tp.isThisType) scope = tpDeclaration;
           if (scope !== undefined) {
-            for (const d of symbol.declarations) if (isNodeDescendantOf(d, scope)) return true;
+            for (const d of getDeclarations(symbol)) if (isNodeDescendantOf(d, scope)) return true;
             const args = getTypeArgumentNodes(node);
             if (args !== undefined) for (const a of args.nodes) if (this.containsReference(a)) return true;
             return false;
@@ -596,9 +634,9 @@ export function isNodeDescendantOf(node: Node, ancestor: Node): boolean {
  */
 export function isTypeParameterPossiblyReferenced(c: Checker, tp: Type, node: Node): boolean {
   const typeParameter = tp as TypeParameter;
-  if (tp.symbol === undefined || tp.symbol.declarations.length !== 1) return true;
+  if (tp.symbol === undefined || declarationCount(tp.symbol) !== 1) return true;
   const finder = new ReferenceFinder(c, typeParameter);
-  const container = tp.symbol.declarations[0]!.parent;
+  const container = tp.symbol.declaration!.parent;
   for (let n: Node | undefined = node; n !== container; n = n.parent) {
     if (n === undefined || n.kind === SyntaxKind.Block) return true;
     if (n.kind === SyntaxKind.ConditionalType && finder.containsReference((n as ConditionalTypeNode).extendsType))
@@ -650,9 +688,15 @@ export function instantiateTypeAlias(
   alias: TypeAlias | undefined,
   mapper: TypeMapper,
 ): TypeAlias | undefined {
-  return alias === undefined
-    ? undefined
-    : new TypeAlias(alias.symbol, instantiateTypes(c, alias.typeArguments, mapper));
+  if (alias === undefined) return undefined;
+  const typeArguments = instantiateTypes(c, alias.typeArguments, mapper);
+  // The alias's type keeps its type arguments.
+  return new TypeAlias(
+    alias.symbol,
+    typeArguments === alias.typeArguments
+      ? typeArguments
+      : c.typeLists.intern(typeListHash(typeArguments, undefined, 0), typeArguments),
+  );
 }
 
 /** Instantiates each type; returns `types` itself when nothing changed. */
@@ -785,7 +829,7 @@ export function newInstantiatedSymbol(c: Checker, symbol: Symbol, mapper: TypeMa
     CheckFlags.Instantiated |
     (symbol.checkFlags &
       (CheckFlags.Readonly | CheckFlags.Late | CheckFlags.OptionalParameter | CheckFlags.RestParameter));
-  result.declarations = symbol.declarations;
+  copyDeclarations(result, symbol);
   result.parent = symbol.parent;
   result.valueDeclaration = symbol.valueDeclaration;
   const id = getSymbolId(result);
@@ -797,8 +841,8 @@ export function newInstantiatedSymbol(c: Checker, symbol: Symbol, mapper: TypeMa
 
 /** Conservatively, whether a parameter or member's type can't reference `this`. */
 export function isThisless(symbol: Symbol): boolean {
-  if (symbol.declarations.length !== 1) return false;
-  const declaration = symbol.declarations[0]!;
+  if (declarationCount(symbol) !== 1) return false;
+  const declaration = symbol.declaration!;
   switch (declaration.kind) {
     case SyntaxKind.Parameter:
     case SyntaxKind.PropertyDeclaration:

package/src/compiler/link-tables.ts

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

package/src/compiler/name-resolver.ts

@@ -55,9 +55,9 @@ import {
   getIsolatedModules,
   getUseDefineForClassFields,
 } from './options.js';
-import { InternalSymbolName, Symbol, SymbolFlags, type SymbolTable } from './symbol.js';
 import { SyntaxKind } from './syntax-kind.js';
 import { ScriptTarget } from './types.js';
+import { getDeclarations, InternalSymbolName, Symbol, SymbolFlags, type SymbolTable } from './symbol.js';
 
 export class NameResolver {
   readonly compilerOptions: CompilerOptions;
@@ -596,7 +596,7 @@ function isInParameter(declaration: Node | undefined): boolean {
 
 /** The local symbol of an `export default` declaration. */
 export function getLocalSymbolForExportDefault(symbol: Symbol): Symbol | undefined {
-  const declarations = symbol.declarations;
+  const declarations = getDeclarations(symbol);
   if (declarations.length === 0 || !hasSyntacticModifier(declarations[0]!, ModifierFlags.Default)) return undefined;
   for (const declaration of declarations) {
     const localSymbol = getLocalSymbol(declaration);
@@ -623,7 +623,7 @@ function isDeferredContext(location: Node, lastLocation: Node | undefined): bool
 }
 
 function isTypeParameterSymbolDeclaredInContainer(symbol: Symbol, container: Node): boolean {
-  for (const declaration of symbol.declarations)
+  for (const declaration of getDeclarations(symbol))
     if (declaration.kind === SyntaxKind.TypeParameter && declaration.parent === container) return true;
   return false;
 }

package/src/compiler/node-builder-names.ts

@@ -59,14 +59,6 @@ import type { KnownSymlinks } from './symlinks.js';
 import { isExternalModuleAugmentation } from './transformers/declarations-syntactic.js';
 import { EmitFlags } from './printer/emit-flags.js';
 import { isIdentifierText } from './scanner.js';
-import {
-  CheckFlags,
-  InternalSymbolName,
-  type Symbol,
-  SymbolFlags,
-  escapeInternalSymbolName,
-  getSymbolId,
-} from './symbol.js';
 import {
   getAccessibleSymbolChain,
   getAliasForSymbolInContainer,
@@ -81,6 +73,16 @@ import { SyntaxKind } from './syntax-kind.js';
 import { NodeBuilderFlags, NodeBuilderInternalFlags } from './transformers/declarations-resolver.js';
 import { TokenFlags } from './types.js';
 import { type NodeBuilder, classifyPropertyName, isNumericLiteralName } from './node-builder.js';
+import {
+  CheckFlags,
+  declarationCount,
+  escapeInternalSymbolName,
+  getDeclarations,
+  getSymbolId,
+  InternalSymbolName,
+  type Symbol,
+  SymbolFlags,
+} from './symbol.js';
 
 // ---- Symbol chains
 
@@ -325,7 +327,7 @@ function createAccessFromSymbolChain(
   }
   if (symbolName.length === 0) {
     let name: Node | undefined = undefined;
-    for (const d of symbol.declarations) {
+    for (const d of getDeclarations(symbol)) {
       name = getNameOfDeclaration(d);
       if (name !== undefined) break;
     }
@@ -658,14 +660,14 @@ export function getNameOfSymbolAsWritten(b: NodeBuilder, symbol: Symbol): string
     (b.flags & NodeBuilderFlags.UseAliasDefinedOutsideCurrentScope) === 0 &&
     // Not the first part of an entity name, synthesized, or from another binding context.
     ((b.flags & NodeBuilderFlags.InInitialEntityName) === 0 ||
-      symbol.declarations.length === 0 ||
+      declarationCount(symbol) === 0 ||
       (b.enclosingDeclaration !== undefined &&
-        findDefaultBindingContext(symbol.declarations[0]!) !== findDefaultBindingContext(b.enclosingDeclaration)))
+        findDefaultBindingContext(symbol.declaration!) !== findDefaultBindingContext(b.enclosingDeclaration)))
   )
     return 'default';
-  if (symbol.declarations.length > 0) {
+  if (declarationCount(symbol) > 0) {
     let name: Node | undefined = undefined;
-    for (const d of symbol.declarations) {
+    for (const d of getDeclarations(symbol)) {
       name = getNameOfDeclaration(d);
       if (name !== undefined) break;
     }
@@ -679,7 +681,7 @@ export function getNameOfSymbolAsWritten(b: NodeBuilder, symbol: Symbol): string
       }
       return declarationNameToString(getSourceFileOfNode(name), name);
     }
-    const declaration = symbol.declarations[0]!;
+    const declaration = symbol.declaration!;
     const parent = declaration.parent;
     if (parent !== undefined && parent.kind === SyntaxKind.VariableDeclaration) {
       const parentName = getName(parent)!;
@@ -725,7 +727,7 @@ export function getPropertyNameNodeForSymbol(b: NodeBuilder, symbol: Symbol): No
     if (declarationName !== undefined && declarationName.kind === SyntaxKind.PrivateIdentifier)
       return b.cloneSynthesized(declarationName);
   }
-  const declarations = symbol.declarations;
+  const declarations = getDeclarations(symbol);
   let stringNamed = declarations.length !== 0;
   for (const d of declarations)
     if (!isStringNamed(b, d)) {
@@ -810,7 +812,7 @@ export function getSpecifierForModuleSymbol(b: NodeBuilder, symbol: Symbol, over
   const c = b.c;
   let file = asSourceFile(getDeclarationOfKind(symbol, SyntaxKind.SourceFile));
   if (file === undefined)
-    for (const d of symbol.declarations) {
+    for (const d of getDeclarations(symbol)) {
       const equivalent = getFileSymbolIfFileSymbolExportEqualsContainer(c, d, symbol);
       if (equivalent !== undefined) {
         file = asSourceFile(getDeclarationOfKind(equivalent, SyntaxKind.SourceFile));
@@ -890,14 +892,14 @@ function getModuleSpecifierHost(c: Checker): ModuleSpecifierHost {
 
 /** The name of an ambient module declaring `moduleSymbol`, or of the one whose `export =` it is, else `''`. */
 function tryGetModuleNameFromAmbientModule(c: Checker, moduleSymbol: Symbol): string {
-  for (const d of moduleSymbol.declarations) {
+  for (const d of getDeclarations(moduleSymbol)) {
     const name = isModuleWithStringLiteralName(d) ? getName(d)! : undefined;
     if (name !== undefined && (!isModuleAugmentationExternal(d) || !isExternalModuleNameRelative(getText(name))))
       return getText(name);
   }
   // A namespace exported with `export =` from an ambient module: `import { c } from "m"` names
   // `ns.c` for `declare module "m" { namespace ns { class c {} } export = ns; }`.
-  for (const d of moduleSymbol.declarations) {
+  for (const d of getDeclarations(moduleSymbol)) {
     if (d.kind !== SyntaxKind.ModuleDeclaration) continue;
     let container: Node | undefined = d;
     while (container !== undefined && !isModuleWithStringLiteralName(container)) container = container.parent;
@@ -1060,7 +1062,7 @@ function asSourceFile(node: Node | undefined): SourceFile | undefined {
 function getSourceFileOfModule(symbol: Symbol): SourceFile | undefined {
   let d = symbol.valueDeclaration;
   if (d === undefined)
-    for (const declaration of symbol.declarations)
+    for (const declaration of getDeclarations(symbol))
       if (!isExternalModuleAugmentation(declaration) && !isGlobalScopeAugmentation(declaration)) {
         d = declaration;
         break;