tsc-ts 0.0.5 → 0.0.7

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/class-fields.ts

@@ -55,6 +55,9 @@ import {
   getMembers,
   getModifiers,
   getName,
+  callQuestionDotToken,
+  callTypeArguments,
+  newCallExpression,
 } from '../ast.js';
 import { isLeftHandSideExpression } from '../ast-utilities.js';
 import {
@@ -1209,7 +1212,14 @@ export class ClassFieldsTransformer extends Transformer {
     if (node instanceof CallExpression)
       return factory.cloneNode(
         node,
-        new CallExpression(node.expression, node.questionDotToken, node.typeArguments, node.arguments, node.flags),
+        newCallExpression(
+          node.expression,
+          callQuestionDotToken(node),
+          callTypeArguments(node),
+          node.arguments,
+          node.flags,
+          false,
+        ),
       );
     return factory.cloneNode(node, node.deepClone());
   }
@@ -1232,7 +1242,7 @@ export class ClassFieldsTransformer extends Transformer {
       const call = factory.created(
         new PropertyAccessExpression(
           target,
-          optional ? node.questionDotToken : undefined,
+          optional ? callQuestionDotToken(node) : undefined,
           factory.createIdentifier('call'),
           optional ? NodeFlags.OptionalChain : NodeFlags.None,
         ),

package/src/compiler/transformers/commonjs-module.ts

@@ -63,6 +63,7 @@ import {
   ModifierList,
   getElements,
   getName,
+  callQuestionDotToken,
 } from '../ast.js';
 import { getExternalModuleName, isImportCall, isInJSFile, isRequireCall } from '../ast-utilities.js';
 import { isAssignmentExpression, isDestructuringAssignment } from '../binder-utilities.js';
@@ -1248,7 +1249,7 @@ export class CommonJSModuleTransformer extends Transformer {
       const updated = this.factory.updateCallExpression(
         node,
         expression,
-        node.questionDotToken,
+        callQuestionDotToken(node),
         undefined,
         this.visitNodes(node.arguments)!,
         node.flags,
@@ -1340,7 +1341,7 @@ export class CommonJSModuleTransformer extends Transformer {
       if (rewritten !== first || visitedRest !== rest)
         args = new NodeList(args.pos, args.end, [rewritten].concat(visitedRest));
     }
-    return factory.updateCallExpression(node, expression, node.questionDotToken, undefined, args, node.flags);
+    return factory.updateCallExpression(node, expression, callQuestionDotToken(node), undefined, args, node.flags);
   }
 
   private visitTaggedTemplateExpression(node: TaggedTemplateExpression): Node {

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

@@ -33,13 +33,14 @@ import {
   getSymbol,
   getType,
   getTypeParameters,
+  propertyAssignmentPostfixToken,
 } from '../ast.js';
 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 +360,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 +389,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 (
@@ -541,7 +545,7 @@ export class PseudoChecker {
         }
         case SyntaxKind.PropertyAssignment: {
           const assignment = property as PropertyAssignment;
-          const postfix = assignment.postfixToken;
+          const postfix = propertyAssignmentPostfixToken(assignment);
           members.push(
             new PseudoMember(
               PseudoMemberKind.Property,
@@ -695,7 +699,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++;