tsc-ts 0.0.5 → 0.0.7

package/src/compiler/checker-symbol-types.ts

@@ -4,17 +4,7 @@ import { checkJsxAttribute } from './checker-jsx.js';
 import { getTargetOfAliasDeclaration, resolveExternalModuleSymbol } from './checker-modules.js';
 import { CachedTypeKind, cachedTypeKey, CheckMode } from './checker-types.js';
 import {
-  type ArrayLiteralExpression,
-  type BindingElement,
-  type BindingPattern,
-  type BinaryExpression,
-  type Block,
-  type ConditionalExpression,
-  type ForInOrOfStatement,
   ModifierFlags,
-  NodeVisitor,
-  type ObjectLiteralExpression,
-  type PrefixUnaryExpression,
   type Node,
   NodeFlags,
   getArguments,
@@ -28,14 +18,12 @@ import {
   getDotDotDotToken,
   getElements,
   getExpression,
-  getLocals,
   getPostfixToken,
   getQuestionToken,
   getText,
   type PropertyAssignment,
   type ShorthandPropertyAssignment,
   type SourceFile,
-  type VariableDeclarationList,
 } from './ast.js';
 import {
   declarationNameToString,
@@ -48,15 +36,11 @@ import {
   hasStaticModifier,
   hasSyntacticModifier,
   isCatchClauseVariableDeclarationOrBindingElement,
-  isExternalModule,
   isJsonSourceFile,
   isTypeNodeKind,
-  skipParentheses,
 } from './binder-utilities.js';
 import { identifierToKeywordKind } from './scanner.js';
-import { tsgoCheckerSlots } from './symbol-accessibility.js';
 import { type DiagnosticMessage, Diagnostics } from './diagnostics.js';
-import { CheckFlags, type Symbol, SymbolFlags, getSymbolId } from './symbol.js';
 import { SyntaxKind } from './syntax-kind.js';
 import { type Checker, createDiagnosticForNode } from './checker.js';
 import {
@@ -93,7 +77,6 @@ import {
   pushTypeResolution,
   reportCircularityError,
   resolveAlias,
-  getMergedSymbol,
   TypeSystemPropertyName,
   getGlobalTypeAliasSymbol,
   resolveName,
@@ -118,6 +101,8 @@ import {
   getPropertiesOfType,
   getPropertyOfObjectType,
   isObjectLiteralType,
+  keepPropertiesOnly,
+  scannedLiteralPropertiesLimit,
 } from './checker-members.js';
 import { typeToString, symbolToString } from './type-printer.js';
 import { getTypeOfMappedSymbol, getIndexType } from './checker-type-operators.js';
@@ -129,7 +114,6 @@ import {
 import {
   getReturnTypeFromBody,
   getTypeOfObjectLiteralMethod,
-  ReturnCollector,
   shouldReportErrorsFromWideningWithContextualSignature,
 } from './checker-functions.js';
 import { getTypeOfReverseMappedSymbol } from './checker-inference.js';
@@ -139,13 +123,13 @@ import {
   getContextualThisParameterType,
   checkExpressionCached,
   checkExpressionEx,
-  isConstTypeReference,
 } from './checker-expressions.js';
 import { checkPropertyAssignment, checkShorthandPropertyAssignment } from './checker-object-literals.js';
 import { getTypeForBindingElement, getTypeFromBindingPattern } from './checker-destructuring.js';
 import { checkRightHandSideOfForOf } from './checker-statements.js';
 import { getTypeWithFacts, TypeFacts, hasTypeFacts, getNonNullableType } from './checker-flow.js';
 import { getTypeOfModuleExportsSymbol, getWidenedTypeForAssignmentDeclaration } from './checker-javascript.js';
+import { CheckFlags, copyDeclarations, getDeclarations, getSymbolId, type Symbol, SymbolFlags } from './symbol.js';
 
 export function getTypeOfSymbol(c: Checker, symbol: Symbol): Type {
   const checkFlags = symbol.checkFlags;
@@ -420,7 +404,8 @@ export function getTypeForVariableLikeDeclaration(
     // A set accessor parameter takes the getter's type.
     if (fn.kind === SyntaxKind.SetAccessor) {
       const fnSymbol = getSymbolOfDeclaration(c, fn);
-      const getter = fnSymbol?.declarations.find((d) => d.kind === SyntaxKind.GetAccessor);
+      const getter =
+        fnSymbol !== undefined ? getDeclarations(fnSymbol).find((d) => d.kind === SyntaxKind.GetAccessor) : undefined;
       if (getter !== undefined) {
         const getterSignature = getSignatureFromDeclaration(c, getter);
         // An unannotated `this` of a setter takes the getter's `this` type.
@@ -589,7 +574,7 @@ function reportWideningErrorsInType(c: Checker, t: Type): boolean {
       if (errorReported) continue;
       // Property types can come from object literal normalization in unions.
       let valueDeclaration: Node | undefined;
-      for (const d of p.declarations) {
+      for (const d of getDeclarations(p)) {
         const v = getSymbol(d)?.valueDeclaration;
         if (v !== undefined && v.parent === t.symbol?.valueDeclaration) {
           valueDeclaration = d;
@@ -813,6 +798,7 @@ function getWidenedTypeOfObjectLiteral(c: Checker, t: Type, context: WideningCon
       ),
   );
   const result = createAnonymousType(c, t.symbol, members, [], [], infos);
+  keepPropertiesOnly(c, result, members, scannedLiteralPropertiesLimit);
   result.objectFlags |= t.objectFlags & (ObjectFlags.JSLiteral | ObjectFlags.NonInferrableType);
   // The root context widens each object literal once; a property's context may widen one literal
   // for several siblings.
@@ -834,7 +820,7 @@ function getWidenedProperty(c: Checker, prop: Symbol, context: WideningContext |
 
 function createSymbolWithWidenedType(c: Checker, prop: Symbol, t: Type): Symbol {
   const result = c.newSymbolWithCheckFlags(prop.flags, prop.name, prop.checkFlags & CheckFlags.Readonly);
-  result.declarations = prop.declarations;
+  copyDeclarations(result, prop);
   result.parent = prop.parent;
   result.valueDeclaration = prop.valueDeclaration;
   const id = getSymbolId(result);
@@ -845,926 +831,20 @@ function createSymbolWithWidenedType(c: Checker, prop: Symbol, t: Type): Symbol
 }
 
 /**
- * An optional `undefined` property standing in for `prop`, the last property of that name among the
- * sibling object literals (getPropertiesOfContext). It carries the declarations of the property it is
- * created from, which order it among the members when they are printed.
- *
- * tsgo caches one such symbol per name and checker, so the declarations come from the first literal
- * its checker widened with that name missing in a sibling. Its checkers check the program's files
- * round robin, each file from the top. tsc-ts's checkers take files in another order, and a checker
- * can infer a file's functions for an importer before it checks the file, so the first union is found
- * in the sources of the files tsgo checks with the checker of the property's file, up to that file
- * (`firstSiblingProperty`), which doesn't depend on the order of checking. Without one, the property
- * is cached per sibling property. The order differs from tsgo's where tsgo's checker first infers a
- * function of a file of another checker, or a later function of the file.
+ * An optional `undefined` property standing in for `prop`, a property of a sibling object literal
+ * (getPropertiesOfContext), one per property. It carries the declarations of `prop`, which order it
+ * among the members when they are printed.
  */
 function getUndefinedProperty(c: Checker, prop: Symbol): Symbol {
-  const member = prop.declarations.length > 0 ? firstSiblingProperty(c, prop.declarations[0]!, prop.name) : undefined;
-  const first = member !== undefined ? getSymbol(member) : undefined;
-  const source = first ?? prop;
-  const key = getSymbolId(source);
+  const key = getSymbolId(prop);
   const cached = c.undefinedProperties.get(key);
   if (cached !== undefined) return cached;
-  const result = createSymbolWithWidenedType(c, source, c.undefinedOrMissingType);
+  const result = createSymbolWithWidenedType(c, prop, c.undefinedOrMissingType);
   result.flags |= SymbolFlags.Optional;
-  // The properties of a literal in an `as const` assertion are readonly.
-  if (first !== undefined && isInConstAssertion(member!.parent!)) result.checkFlags |= CheckFlags.Readonly;
   c.undefinedProperties.set(key, result);
   return result;
 }
 
-/**
- * The property of `name` in the first union of object literals that leaves `name` missing in one of
- * them, among the files tsgo checks with the checker of the declaration's file, up to that file: the
- * last literal's property of that name. tsgo's checker `k` checks files `k`, `k + n`, `k + 2n`, ...
- * in order (`tsgoCheckerSlots`). Unions are those of the returned expressions of a function without
- * a return type, and of the alternatives of an initializer without a type (`?:`, `||`, `??`, array
- * elements, an element access of an array literal, and the values of a property across the literals),
- * of the variables of a `for...of`, of the object of a method call and of the expression of a type
- * assertion. In a file, they are taken in the order a checker checking the file from the top widens
- * them (`SiblingPropertyScan`).
- */
-function firstSiblingProperty(c: Checker, declaration: Node, name: string): Node | undefined {
-  const file = getSourceFileOfNode(declaration);
-  const index = c.fileIndex.get(file);
-  if (index === undefined) return siblingPropertiesOfFile(c, file).get(name);
-  const slots = tsgoCheckerSlots(c);
-  let slot = c.slotSiblingProperties.get(index % slots);
-  if (slot === undefined) {
-    slot = new SlotSiblingProperties(index % slots);
-    c.slotSiblingProperties.set(index % slots, slot);
-  }
-  for (; slot.next <= index; slot.next += slots)
-    for (const [n, member] of siblingPropertiesOfFile(c, c.files[slot.next]!))
-      if (!slot.members.has(n)) {
-        slot.members.set(n, member);
-        slot.fileIndexes.set(n, slot.next);
-      }
-  const found = slot.fileIndexes.get(name);
-  return found !== undefined && found <= index ? slot.members.get(name) : undefined;
-}
-
-/**
- * By name, the first property of the unions of `file` that leave the name missing: what a parse thread
- * found (`SourceFile.siblingProperties`), or else the checker's own scan.
- */
-function siblingPropertiesOfFile(c: Checker, file: SourceFile): Map<string, Node> {
-  // A parse thread's scan takes array literals to have the global Array type.
-  if (file.siblingProperties !== undefined && c.globalArrayType !== c.emptyGenericType) return file.siblingProperties;
-  let first = c.firstSiblingProperties.get(file);
-  if (first === undefined) {
-    first = scanSiblingProperties(file, c)!;
-    c.firstSiblingProperties.set(file, first);
-  }
-  return first;
-}
-
-/**
- * By name, the first property of the unions of `file`'s object literals that leave the name missing.
- * Without a checker, as on a parse thread, array literals are taken to have the global Array type, and
- * the result is undefined where an enum the scan can't resolve decides which literals subtype reduction
- * leaves out (`enumKeyOfMemberAccess`); the checker then scans the file itself.
- */
-export function scanSiblingProperties(file: SourceFile, c: Checker | undefined): Map<string, Node> | undefined {
-  if (file.isDeclarationFile) return new Map<string, Node>();
-  const scan = new SiblingPropertyScan(c);
-  file.forEachChild(scan);
-  scan.widenAll();
-  return scan.unresolved ? undefined : scan.members;
-}
-
-/** The first property of each name among the files of one of tsgo's checkers, scanned in order. */
-export class SlotSiblingProperties {
-  readonly members = new Map<string, Node>();
-  /** The index of the file of each name's property. */
-  readonly fileIndexes = new Map<string, number>();
-  /** The index of the next file of the checker to scan. */
-  next: number;
-
-  constructor(first: number) {
-    this.next = first;
-  }
-}
-
-/** Whether an object literal is in an `as const` assertion, through arrays, spreads and properties. */
-function isInConstAssertion(literal: Node): boolean {
-  for (let node = literal; node.parent !== undefined; node = node.parent) {
-    switch (node.parent.kind) {
-      case SyntaxKind.ParenthesizedExpression:
-      case SyntaxKind.ArrayLiteralExpression:
-      case SyntaxKind.SpreadElement:
-      case SyntaxKind.PropertyAssignment:
-      case SyntaxKind.ObjectLiteralExpression:
-        continue;
-      case SyntaxKind.AsExpression:
-      case SyntaxKind.TypeAssertionExpression:
-        return isConstTypeReference(getType(node.parent)!);
-    }
-    return false;
-  }
-  return false;
-}
-
-/** An expression whose type is widened, at the position where a checker widens it. */
-class WideningRoot {
-  constructor(
-    readonly position: number,
-    /** The function whose returned expressions these are, widened once. */
-    readonly func: Node | undefined,
-    /** The expressions whose types are unioned and widened. */
-    readonly alternatives: Node[],
-    /** The expressions whose calls, innermost first, infer their functions' return types before. */
-    readonly sources: Node[],
-    /** The calls of `sources` that may call a function of the file (`SiblingPropertyScan.callees`). */
-    public calls: Node[] | undefined = undefined,
-  ) {}
-}
-
-/**
- * The unions a checker widens while checking the file's statements or the body of one deferred function, and
- * the deferred functions it queues there.
- */
-class CheckScope {
-  readonly roots: WideningRoot[] = [];
-  readonly deferred: CheckScope[] = [];
-  /** The calls by a name (`calleeName`), which infer where they end. */
-  readonly calls: Node[] = [];
-
-  constructor(readonly position: number) {}
-}
-
-/**
- * Whether a checker checks `node`'s body only as a deferred node: a function expression, arrow
- * function or object literal method or accessor whose return type is written. Without one, the
- * checker infers the return type where it reaches the function, from the returned expressions and
- * what they refer to.
- */
-function isDeferredCheck(node: Node): boolean {
-  switch (node.kind) {
-    case SyntaxKind.FunctionExpression:
-    case SyntaxKind.ArrowFunction:
-      return getType(node) !== undefined;
-    case SyntaxKind.MethodDeclaration:
-    case SyntaxKind.GetAccessor:
-      return node.parent?.kind === SyntaxKind.ObjectLiteralExpression && getType(node) !== undefined;
-    case SyntaxKind.SetAccessor:
-      return node.parent?.kind === SyntaxKind.ObjectLiteralExpression;
-  }
-  return false;
-}
-
-/**
- * Finds the unions of a file's object literals in the order a checker widens them: an initializer
- * where it is, and a function's returned expressions at its first `return`, where the checker
- * infers its return type. A call of a function of the file, by a name that resolves to it or as
- * `this.name(...)` in a class, infers that function's return type where the call is, and before the
- * union of the expression the call is in. The bodies of function expressions, arrow functions and
- * object literal methods and accessors with a written return type are checked after the file's
- * statements, so their unions widen then.
- */
-class SiblingPropertyScan extends NodeVisitor {
-  /** The checker that resolves imported enums, or undefined on a parse thread. */
-  readonly c: Checker | undefined;
-  /** By name, the property of the first union that leaves the name missing in a literal. */
-  readonly members = new Map<string, Node>();
-  /**
-   * Whether array literals have an array type, whose elements are widened as one union. Without the
-   * global Array type (--noLib) an array literal is an empty object type.
-   */
-  private readonly arrays: boolean;
-  /** Whether an enum the scan can't resolve without a checker decided which literals were left out. */
-  unresolved = false;
-  /** The enums of the members that values refer to, numbered in the order the scan meets them. */
-  private readonly enums = new Map<Symbol, number>();
-  private readonly fileScope = new CheckScope(0);
-  /** The scope of the innermost deferred function around the node being visited. */
-  private scope = this.fileScope;
-  /** The returned expressions of each function without a return type. */
-  private readonly returned = new Map<Node, WideningRoot>();
-  /** The names a call can call those functions by (`functionName`). */
-  private readonly callees = new Set<string>();
-  private readonly widened = new Set<Node>();
-  /** The functions and methods of each class, by name. */
-  private readonly classFunctions = new Map<Node, Map<string, Node>>();
-
-  constructor(c: Checker | undefined) {
-    super();
-    this.c = c;
-    this.arrays = c === undefined || c.globalArrayType !== c.emptyGenericType;
-  }
-
-  /** The key of the values that are members of `symbol`, an enum, in this scan. */
-  enumKey(symbol: Symbol): string {
-    let id = this.enums.get(symbol);
-    if (id === undefined) {
-      id = this.enums.size;
-      this.enums.set(symbol, id);
-    }
-    return 'enum ' + id;
-  }
-
-  visitNode(node: Node): boolean {
-    switch (node.kind) {
-      case SyntaxKind.FunctionDeclaration:
-      case SyntaxKind.FunctionExpression:
-      case SyntaxKind.ArrowFunction:
-      case SyntaxKind.MethodDeclaration:
-      case SyntaxKind.GetAccessor: {
-        const body = getBody(node);
-        if (body === undefined || getType(node) !== undefined) break;
-        const returned: Node[] = [];
-        const sources: Node[] = [];
-        let position = body.pos;
-        if (body.kind === SyntaxKind.Block) {
-          const collector = new ReturnCollector();
-          collector.visitStatements(body as Block);
-          if (collector.returns.length > 0) position = collector.returns[0]!.pos;
-          for (const r of collector.returns)
-            if (r.expression !== undefined) {
-              addAlternatives(r.expression, returned, this.arrays);
-              sources.push(r.expression);
-            }
-        } else {
-          addAlternatives(body, returned, this.arrays);
-          sources.push(body);
-        }
-        if (returned.length === 0) break;
-        const root = new WideningRoot(position, node, returned, sources);
-        this.returned.set(node, root);
-        this.addRoot(root);
-        if (node.kind === SyntaxKind.MethodDeclaration || node.kind === SyntaxKind.GetAccessor)
-          this.addClassFunction(node, node);
-        break;
-      }
-      case SyntaxKind.VariableDeclaration:
-      case SyntaxKind.PropertyDeclaration:
-      case SyntaxKind.Parameter: {
-        const initializer = getInitializer(node);
-        if (initializer === undefined || getType(node) !== undefined) break;
-        this.addRoot(
-          new WideningRoot(initializer.pos, undefined, addAlternatives(initializer, [], this.arrays), [initializer]),
-        );
-        const value = skipParentheses(initializer);
-        if (
-          node.kind === SyntaxKind.PropertyDeclaration &&
-          (value.kind === SyntaxKind.ArrowFunction || value.kind === SyntaxKind.FunctionExpression)
-        )
-          this.addClassFunction(node, value);
-        break;
-      }
-      case SyntaxKind.ExportAssignment:
-        if (getType(node) === undefined) {
-          const expression = getExpression(node)!;
-          this.addRoot(
-            new WideningRoot(node.pos, undefined, addAlternatives(expression, [], this.arrays), [expression]),
-          );
-        }
-        break;
-      case SyntaxKind.ForOfStatement: {
-        // The variable of `for (const x of e)` has the widened type of e's elements, and each element
-        // of a binding pattern the widened type of its part of them.
-        const statement = node as ForInOrOfStatement;
-        if (statement.initializer.kind !== SyntaxKind.VariableDeclarationList) break;
-        const declaration = (statement.initializer as VariableDeclarationList).declarations.nodes[0];
-        if (declaration === undefined || getType(declaration) !== undefined || !this.arrays) break;
-        const elements: Node[] = [];
-        for (const array of iteratedArrayLiterals(statement.expression)) addArrayElements(array, elements);
-        if (elements.length === 0) break;
-        for (const alternatives of bindingAlternatives(getName(declaration)!, elements))
-          this.addRoot(new WideningRoot(statement.expression.pos, undefined, alternatives, [statement.expression]));
-        break;
-      }
-      case SyntaxKind.CallExpression: {
-        // The object of a method call is widened before the call is resolved.
-        const callee = skipParentheses(getExpression(node)!);
-        if (
-          (callee.kind === SyntaxKind.PropertyAccessExpression || callee.kind === SyntaxKind.ElementAccessExpression) &&
-          mayHoldLiterals(getExpression(callee)!)
-        )
-          this.addExpressionRoot(callee.pos, getExpression(callee)!);
-        // Calls elsewhere, as in statements, infer where they end.
-        if (calleeName(node) !== undefined) this.scope.calls.push(node);
-        break;
-      }
-    }
-    if (isTypeNodeKind(node.kind)) return false;
-    if (
-      (node.kind === SyntaxKind.AsExpression || node.kind === SyntaxKind.TypeAssertionExpression) &&
-      !isConstTypeReference(getType(node)!)
-    ) {
-      // An assertion widens its expression's type in a deferred check, queued after the expression's.
-      node.forEachChild(this);
-      const inner = new CheckScope(node.end);
-      this.scope.deferred.push(inner);
-      const saveScope = this.scope;
-      this.scope = inner;
-      this.addExpressionRoot(node.end, getExpression(node)!);
-      this.scope = saveScope;
-      return false;
-    }
-    if (isDeferredCheck(node)) {
-      const inner = new CheckScope(node.pos);
-      this.scope.deferred.push(inner);
-      const saveScope = this.scope;
-      this.scope = inner;
-      node.forEachChild(this);
-      this.scope = saveScope;
-    } else node.forEachChild(this);
-    return false;
-  }
-
-  private addRoot(root: WideningRoot): void {
-    this.scope.roots.push(root);
-  }
-
-  /** Adds a root for the widened type of `expression` where it holds object or array literals. */
-  private addExpressionRoot(position: number, expression: Node): void {
-    const alternatives = addAlternatives(expression, [], this.arrays);
-    if (
-      alternatives.some(
-        (a) => a.kind === SyntaxKind.ObjectLiteralExpression || a.kind === SyntaxKind.ArrayLiteralExpression,
-      )
-    )
-      this.addRoot(new WideningRoot(position, undefined, alternatives, [expression]));
-  }
-
-  /** Names `func` in its class by `member`, a method or a property it initializes. */
-  private addClassFunction(member: Node, func: Node): void {
-    const name = getName(member);
-    const parent = member.parent!;
-    if (name === undefined || name.kind !== SyntaxKind.Identifier) return;
-    if (parent.kind !== SyntaxKind.ClassDeclaration && parent.kind !== SyntaxKind.ClassExpression) return;
-    let functions = this.classFunctions.get(parent);
-    if (functions === undefined) this.classFunctions.set(parent, (functions = new Map()));
-    if (!functions.has(getText(name))) functions.set(getText(name), func);
-  }
-
-  /**
-   * Widens the unions of the file's statements in order, then those of each deferred node in the
-   * order the checker queues them, which includes the deferred nodes queued while checking one.
-   */
-  widenAll(): void {
-    for (const func of this.returned.keys()) {
-      const name = functionName(func);
-      if (name !== undefined) this.callees.add(name);
-    }
-    const queue = [this.fileScope];
-    for (let i = 0; i < queue.length; i++) {
-      const scope = queue[i]!;
-      if (this.callees.size !== 0)
-        for (const call of scope.calls)
-          if (this.callees.has(calleeName(call)!))
-            scope.roots.push(new WideningRoot(call.end, undefined, [], [], [call]));
-      scope.roots.sort((a, b) => a.position - b.position);
-      scope.deferred.sort((a, b) => a.position - b.position);
-      let next = 0;
-      for (const root of scope.roots) {
-        while (next < scope.deferred.length && scope.deferred[next]!.position < root.position)
-          queue.push(scope.deferred[next++]!);
-        this.widenRoot(root);
-      }
-      while (next < scope.deferred.length) queue.push(scope.deferred[next++]!);
-    }
-  }
-
-  /** Widens a root's unions, after the returned expressions of the functions its calls infer. */
-  private widenRoot(root: WideningRoot): void {
-    if (root.func !== undefined) {
-      if (this.widened.has(root.func)) return;
-      this.widened.add(root.func);
-    }
-    if (this.callees.size === 0) {
-      this.widen(root.alternatives, true);
-      return;
-    }
-    if (root.calls === undefined) {
-      const collector = new CallCollector(this.callees);
-      for (const source of root.sources) collector.visitNode(source);
-      root.calls = collector.calls;
-    }
-    for (const call of root.calls) {
-      const callee = this.calledFunction(call);
-      const returned = callee !== undefined ? this.returned.get(callee) : undefined;
-      if (returned !== undefined) this.widenRoot(returned);
-    }
-    this.widen(root.alternatives, true);
-  }
-
-  /**
-   * The function a call calls: a function declaration or a variable initialized with a function that
-   * the callee's name resolves to (`getLocals` of the scopes around the call), or a method or property
-   * of the class for `this.name(...)` in a class member.
-   */
-  private calledFunction(call: Node): Node | undefined {
-    const callee = skipParentheses(getExpression(call)!);
-    if (callee.kind === SyntaxKind.Identifier) {
-      const name = getText(callee);
-      for (let scope = call.parent; scope !== undefined; scope = scope.parent) {
-        const symbol = getLocals(scope)?.get(name);
-        // A type alias, interface or type parameter of the name doesn't hide a value of an outer scope.
-        if (symbol === undefined || (symbol.flags & (SymbolFlags.Value | SymbolFlags.ExportValue)) === 0) continue;
-        // An exported declaration's local symbol has no value declaration of its own.
-        const declaration =
-          symbol.valueDeclaration ??
-          symbol.declarations.find(
-            (d) => d.kind === SyntaxKind.FunctionDeclaration || d.kind === SyntaxKind.VariableDeclaration,
-          );
-        if (declaration === undefined) return undefined;
-        if (declaration.kind === SyntaxKind.FunctionDeclaration) return declaration;
-        const initializer =
-          declaration.kind === SyntaxKind.VariableDeclaration ? getInitializer(declaration) : undefined;
-        const value = initializer !== undefined ? skipParentheses(initializer) : undefined;
-        return value !== undefined &&
-          (value.kind === SyntaxKind.ArrowFunction || value.kind === SyntaxKind.FunctionExpression)
-          ? value
-          : undefined;
-      }
-      return undefined;
-    }
-    if (callee.kind !== SyntaxKind.PropertyAccessExpression || getExpression(callee)!.kind !== SyntaxKind.ThisKeyword)
-      return undefined;
-    const name = getName(callee)!;
-    const container = thisClass(call);
-    const functions = container !== undefined ? this.classFunctions.get(container) : undefined;
-    return functions !== undefined && name.kind === SyntaxKind.Identifier ? functions.get(getText(name)) : undefined;
-  }
-
-  /**
-   * Records the unions of the alternatives of one widened expression, and of their nested values.
-   * With `reduced`, the alternatives make up one union with subtype reduction (the alternatives of an
-   * expression, the elements of an array literal), which drops a literal whose widened type is the
-   * type of an earlier one (`removeSubtypes` removes the later of two identical types). The values of
-   * a property across literals are not reduced: their union is one of each literal's value.
-   */
-  private widen(alternatives: Node[], reduced: boolean): void {
-    let literals: ObjectLiteralExpression[] = [];
-    for (const a of alternatives)
-      if (a.kind === SyntaxKind.ObjectLiteralExpression) literals.push(a as ObjectLiteralExpression);
-      // The elements of a tuple, an array literal in an `as const` assertion, widen separately.
-      else if (this.arrays && a.kind === SyntaxKind.ArrayLiteralExpression && !isInConstAssertion(a))
-        this.widen(addArrayElements(a as ArrayLiteralExpression, []), true);
-    if (literals.length === 0) return;
-    if (reduced) literals = withoutRepeatedLiterals(this, literals);
-    if (literals.length > 1) this.record(literals);
-    const values = new Map<string, Node[]>();
-    for (const literal of literals)
-      for (const member of literal.properties.nodes) {
-        if (member.kind !== SyntaxKind.PropertyAssignment) continue;
-        const name = staticPropertyName(member);
-        if (name === undefined) continue;
-        let list = values.get(name);
-        if (list === undefined) values.set(name, (list = []));
-        // A value's own alternatives make up one reduced union, one member of the property's values.
-        const own = addAlternatives((member as PropertyAssignment).initializer, [], this.arrays);
-        for (const value of withoutRepeatedLiterals(this, own)) list.push(value);
-      }
-    for (const list of values.values()) this.widen(list, false);
-  }
-
-  /**
-   * Records, for each name that some literal without a spread lacks, the last such literal's property
-   * of that name, unless an earlier union has the name.
-   */
-  private record(literals: ObjectLiteralExpression[]): void {
-    const plain: Map<string, Node>[] = [];
-    for (const literal of literals) {
-      let members: Map<string, Node> | undefined = new Map();
-      for (const member of literal.properties.nodes) {
-        if (member.kind === SyntaxKind.SpreadAssignment) {
-          members = undefined;
-          break;
-        }
-        const name = staticPropertyName(member);
-        if (name !== undefined) members.set(name, member);
-      }
-      if (members !== undefined) plain.push(members);
-    }
-    const last = new Map<string, Node>();
-    for (const members of plain) for (const [name, member] of members) last.set(name, member);
-    for (const [name, member] of last) {
-      // A method's or accessor's symbol has other flags than the property checkObjectLiteral makes of it.
-      if (member.kind !== SyntaxKind.PropertyAssignment && member.kind !== SyntaxKind.ShorthandPropertyAssignment)
-        continue;
-      if (this.members.has(name) || plain.every((members) => members.has(name))) continue;
-      this.members.set(name, member);
-    }
-  }
-}
-
-/**
- * `nodes` without the object literals whose widened types are certainly those of an earlier one:
- * the same property names, each with a value of the same widened type (`widenedTypeKey`). Literals
- * that can have a contextual type are kept: it can keep their properties' literal types.
- */
-function withoutRepeatedLiterals<T extends Node>(scan: SiblingPropertyScan, nodes: T[]): T[] {
-  let keys: string[] | undefined;
-  let result: T[] | undefined;
-  for (let i = 0; i < nodes.length; i++) {
-    const node = nodes[i]!;
-    const key =
-      node.kind === SyntaxKind.ObjectLiteralExpression && !mayHaveContextualType(node)
-        ? widenedTypeKey(scan, node)
-        : undefined;
-    if (key !== undefined) {
-      if (keys === undefined) keys = [];
-      else if (keys.includes(key)) {
-        // Without a checker, an enum the scan can't resolve may or may not make the types the same.
-        if (key.includes(pendingEnumKey)) scan.unresolved = true;
-        if (result === undefined) result = nodes.slice(0, i);
-        continue;
-      }
-      keys.push(key);
-    }
-    result?.push(node);
-  }
-  return result ?? nodes;
-}
-
-/**
- * A key that two expressions of one file share only when their types widen to the same type, or
- * undefined where that isn't known from the syntax: literals by their widened type, members of an
- * enum by the enum, and object literals by their properties' names and keys. Other references can
- * name different symbols or be narrowed differently.
- */
-function widenedTypeKey(scan: SiblingPropertyScan, node: Node): string | undefined {
-  switch (node.kind) {
-    case SyntaxKind.StringLiteral:
-    case SyntaxKind.NoSubstitutionTemplateLiteral:
-    case SyntaxKind.TemplateExpression:
-      return 'string';
-    case SyntaxKind.NumericLiteral:
-      return 'number';
-    case SyntaxKind.BigIntLiteral:
-      return 'bigint';
-    case SyntaxKind.TrueKeyword:
-    case SyntaxKind.FalseKeyword:
-      return 'boolean';
-    case SyntaxKind.RegularExpressionLiteral:
-      return 'RegExp';
-    case SyntaxKind.PrefixUnaryExpression: {
-      const unary = node as PrefixUnaryExpression;
-      const operand = unary.operand.kind;
-      if (unary.operator === SyntaxKind.MinusToken || unary.operator === SyntaxKind.PlusToken) {
-        if (operand === SyntaxKind.NumericLiteral) return 'number';
-        if (operand === SyntaxKind.BigIntLiteral && unary.operator === SyntaxKind.MinusToken) return 'bigint';
-      }
-      return undefined;
-    }
-    case SyntaxKind.PropertyAccessExpression:
-      return enumKeyOfMemberAccess(scan, node);
-    case SyntaxKind.ObjectLiteralExpression: {
-      const members: string[] = [];
-      for (const member of (node as ObjectLiteralExpression).properties.nodes) {
-        if (member.kind !== SyntaxKind.PropertyAssignment) return undefined;
-        const name = staticPropertyName(member);
-        const value = widenedTypeKey(scan, (member as PropertyAssignment).initializer);
-        if (name === undefined || value === undefined) return undefined;
-        members.push(JSON.stringify(name) + ': ' + value);
-      }
-      members.sort();
-      return '{' + members.join(', ') + '}';
-    }
-  }
-  return undefined;
-}
-
-/** The key of a member of an enum that the scan can't resolve without a checker. */
-const pendingEnumKey = 'enum ?';
-
-/**
- * The key of `E.Member` where `E` names an enum in the scopes around the access (`getLocals`, as
- * `calledFunction` finds names) and `Member` is one of its members, not an export of a namespace merged
- * with it: the key of the enum. With a checker, `E` can be imported. Without one, an import, and a
- * global of a script file (whose enum other files can extend), give `pendingEnumKey`.
- */
-function enumKeyOfMemberAccess(scan: SiblingPropertyScan, node: Node): string | undefined {
-  const target = getExpression(node)!;
-  const member = getName(node)!;
-  if (target.kind !== SyntaxKind.Identifier || member.kind !== SyntaxKind.Identifier) return undefined;
-  const name = getText(target);
-  const c = scan.c;
-  for (let scope = node.parent; scope !== undefined; scope = scope.parent) {
-    let symbol = getLocals(scope)?.get(name);
-    if (
-      symbol === undefined ||
-      (symbol.flags & (SymbolFlags.Value | SymbolFlags.ExportValue | SymbolFlags.Alias)) === 0
-    )
-      continue;
-    if (c === undefined) {
-      if ((symbol.flags & SymbolFlags.Alias) !== 0) return pendingEnumKey;
-      if (
-        (symbol.flags & (SymbolFlags.Enum | SymbolFlags.Module)) !== 0 &&
-        !isExternalModule(getSourceFileOfNode(node))
-      )
-        return pendingEnumKey;
-    }
-    if (symbol.exportSymbol !== undefined) symbol = symbol.exportSymbol;
-    if (c !== undefined) {
-      symbol = getMergedSymbol(c, symbol);
-      if ((symbol.flags & SymbolFlags.Alias) !== 0) symbol = resolveAlias(c, symbol);
-    }
-    if ((symbol.flags & SymbolFlags.Enum) === 0) return undefined;
-    // An enum merged with a namespace also exports the namespace's values.
-    const memberSymbol = symbol.exports?.get(getText(member));
-    return memberSymbol !== undefined && (memberSymbol.flags & SymbolFlags.EnumMember) !== 0
-      ? scan.enumKey(symbol)
-      : undefined;
-  }
-  return undefined;
-}
-
-/**
- * Whether an object literal of a widened expression can have a contextual type: under `satisfies`,
- * an assertion or an argument, as a parameter's default, or returned from a function that can have
- * a contextual signature (a function expression that doesn't initialize an untyped declaration, or a
- * method of an object literal). Initializers of untyped declarations, the returns of function
- * declarations and class members, and the objects of property and element accesses have none.
- */
-function mayHaveContextualType(node: Node): boolean {
-  for (let current = node.parent; current !== undefined; current = current.parent) {
-    switch (current.kind) {
-      case SyntaxKind.ParenthesizedExpression:
-      case SyntaxKind.NonNullExpression:
-      case SyntaxKind.AwaitExpression:
-      case SyntaxKind.ConditionalExpression:
-      case SyntaxKind.BinaryExpression:
-      case SyntaxKind.ArrayLiteralExpression:
-      case SyntaxKind.ObjectLiteralExpression:
-      case SyntaxKind.PropertyAssignment:
-      case SyntaxKind.ReturnStatement:
-      case SyntaxKind.Block:
-      case SyntaxKind.IfStatement:
-      case SyntaxKind.DoStatement:
-      case SyntaxKind.WhileStatement:
-      case SyntaxKind.ForStatement:
-      case SyntaxKind.ForInStatement:
-      case SyntaxKind.ForOfStatement:
-      case SyntaxKind.SwitchStatement:
-      case SyntaxKind.CaseBlock:
-      case SyntaxKind.CaseClause:
-      case SyntaxKind.DefaultClause:
-      case SyntaxKind.LabeledStatement:
-      case SyntaxKind.TryStatement:
-      case SyntaxKind.CatchClause:
-        continue;
-      case SyntaxKind.VariableDeclaration:
-      case SyntaxKind.PropertyDeclaration:
-      case SyntaxKind.ExportAssignment:
-      case SyntaxKind.FunctionDeclaration:
-      // The object of a property access, as in a method call, has no contextual type.
-      case SyntaxKind.PropertyAccessExpression:
-      case SyntaxKind.ElementAccessExpression:
-        return false;
-      case SyntaxKind.MethodDeclaration:
-      case SyntaxKind.GetAccessor: {
-        const parent = current.parent!.kind;
-        return parent !== SyntaxKind.ClassDeclaration && parent !== SyntaxKind.ClassExpression;
-      }
-      case SyntaxKind.ArrowFunction:
-      case SyntaxKind.FunctionExpression: {
-        let outer = current.parent!;
-        while (outer.kind === SyntaxKind.ParenthesizedExpression) outer = outer.parent!;
-        return (
-          (outer.kind !== SyntaxKind.VariableDeclaration && outer.kind !== SyntaxKind.PropertyDeclaration) ||
-          getType(outer) !== undefined
-        );
-      }
-      default:
-        return true;
-    }
-  }
-  return true;
-}
-
-/** Collects the calls by one of `names` in an expression, innermost first, outside the functions in it. */
-class CallCollector extends NodeVisitor {
-  readonly calls: Node[] = [];
-
-  constructor(private readonly names: Set<string>) {
-    super();
-  }
-
-  visitNode(node: Node): boolean {
-    if (isFunctionLike(node) || node.kind === SyntaxKind.ClassExpression) return false;
-    node.forEachChild(this);
-    if (node.kind === SyntaxKind.CallExpression) {
-      const name = calleeName(node);
-      if (name !== undefined && this.names.has(name)) this.calls.push(node);
-    }
-    return false;
-  }
-}
-
-/** The name a call calls its function by, `f` in `f(...)` and `this.f(...)`, if the scan can resolve it. */
-function calleeName(call: Node): string | undefined {
-  const callee = skipParentheses(getExpression(call)!);
-  if (callee.kind === SyntaxKind.Identifier) return getText(callee);
-  if (callee.kind !== SyntaxKind.PropertyAccessExpression || getExpression(callee)!.kind !== SyntaxKind.ThisKeyword)
-    return undefined;
-  const name = getName(callee)!;
-  return name.kind === SyntaxKind.Identifier ? getText(name) : undefined;
-}
-
-/**
- * The name calls can call a function without a return type by: a function declaration's, a method's or
- * accessor's, or that of the variable or property a function expression initializes.
- */
-function functionName(func: Node): string | undefined {
-  let node = func;
-  if (func.kind === SyntaxKind.FunctionExpression || func.kind === SyntaxKind.ArrowFunction) {
-    while (node.parent?.kind === SyntaxKind.ParenthesizedExpression) node = node.parent;
-    if (node.parent?.kind !== SyntaxKind.VariableDeclaration && node.parent?.kind !== SyntaxKind.PropertyDeclaration)
-      return undefined;
-    node = node.parent;
-  }
-  const name = getName(node);
-  return name?.kind === SyntaxKind.Identifier ? getText(name) : undefined;
-}
-
-/** Whether an expression's alternatives (`addAlternatives`) can hold object or array literals. */
-function mayHoldLiterals(node: Node): boolean {
-  switch (skipParentheses(node).kind) {
-    case SyntaxKind.ObjectLiteralExpression:
-    case SyntaxKind.ArrayLiteralExpression:
-    case SyntaxKind.ConditionalExpression:
-    case SyntaxKind.BinaryExpression:
-    case SyntaxKind.NonNullExpression:
-    case SyntaxKind.SatisfiesExpression:
-    case SyntaxKind.AwaitExpression:
-    case SyntaxKind.AsExpression:
-    case SyntaxKind.TypeAssertionExpression:
-      return true;
-  }
-  return false;
-}
-
-/** The class whose instance `this` is at `node`, through arrow functions, in a member or property initializer. */
-function thisClass(node: Node): Node | undefined {
-  for (let current = node.parent; current !== undefined; current = current.parent) {
-    if (current.kind === SyntaxKind.ArrowFunction) continue;
-    if (
-      current.kind === SyntaxKind.MethodDeclaration ||
-      current.kind === SyntaxKind.GetAccessor ||
-      current.kind === SyntaxKind.SetAccessor ||
-      current.kind === SyntaxKind.Constructor ||
-      current.kind === SyntaxKind.PropertyDeclaration
-    ) {
-      const parent = current.parent!;
-      return parent.kind === SyntaxKind.ClassDeclaration || parent.kind === SyntaxKind.ClassExpression
-        ? parent
-        : undefined;
-    }
-    if (isFunctionLike(current) || current.kind === SyntaxKind.SourceFile) return undefined;
-  }
-  return undefined;
-}
-
-/**
- * Adds the expressions whose types make up the type of `node`: both sides of `?:`, `||` and `??`,
- * and the elements of an array literal that `node` indexes when `arrays` (see SiblingPropertyScan).
- */
-function addAlternatives(node: Node, out: Node[], arrays: boolean): Node[] {
-  switch (node.kind) {
-    case SyntaxKind.ParenthesizedExpression:
-    case SyntaxKind.NonNullExpression:
-    case SyntaxKind.SatisfiesExpression:
-    case SyntaxKind.AwaitExpression:
-      return addAlternatives(getExpression(node)!, out, arrays);
-    case SyntaxKind.AsExpression:
-    case SyntaxKind.TypeAssertionExpression:
-      // An object literal in an `as const` assertion is still an object literal type, with readonly
-      // properties; an array literal in one is a tuple, whose elements widen separately.
-      if (isConstAssertion(node) && skipParentheses(getExpression(node)!).kind === SyntaxKind.ObjectLiteralExpression)
-        return addAlternatives(getExpression(node)!, out, arrays);
-      break;
-    case SyntaxKind.ConditionalExpression:
-      addAlternatives((node as ConditionalExpression).whenTrue, out, arrays);
-      return addAlternatives((node as ConditionalExpression).whenFalse, out, arrays);
-    case SyntaxKind.BinaryExpression: {
-      const binary = node as BinaryExpression;
-      switch (binary.operatorToken.kind) {
-        case SyntaxKind.BarBarToken:
-        case SyntaxKind.QuestionQuestionToken:
-          addAlternatives(binary.left, out, arrays);
-          return addAlternatives(binary.right, out, arrays);
-        case SyntaxKind.AmpersandAmpersandToken:
-        case SyntaxKind.CommaToken:
-          return addAlternatives(binary.right, out, arrays);
-      }
-      break;
-    }
-    case SyntaxKind.ElementAccessExpression: {
-      // `[a, b][i]` has the type of the array's elements, which the declaration widens as one union.
-      const array = skipParentheses(getExpression(node)!);
-      if (!arrays || array.kind !== SyntaxKind.ArrayLiteralExpression) break;
-      for (const e of (array as ArrayLiteralExpression).elements.nodes)
-        if (e.kind !== SyntaxKind.SpreadElement) addAlternatives(e, out, arrays);
-      return out;
-    }
-  }
-  out.push(node);
-  return out;
-}
-
-/**
- * The alternatives of the elements of an array literal, whose types make its element type, with those
- * of the array literals that its spread elements spread. Used where array literals have an array type
- * (`SiblingPropertyScan.arrays`), as are `iteratedArrayLiterals` and `bindingAlternatives`.
- */
-function addArrayElements(array: ArrayLiteralExpression, out: Node[]): Node[] {
-  for (const e of array.elements.nodes)
-    if (e.kind !== SyntaxKind.SpreadElement) addAlternatives(e, out, true);
-    else
-      for (const spread of addAlternatives(getExpression(e)!, [], true))
-        if (spread.kind === SyntaxKind.ArrayLiteralExpression) addArrayElements(spread as ArrayLiteralExpression, out);
-  return out;
-}
-
-/** The array literals whose elements a `for...of` over `expression` iterates, through `as const`. */
-function iteratedArrayLiterals(expression: Node): ArrayLiteralExpression[] {
-  const arrays: ArrayLiteralExpression[] = [];
-  for (const a of addAlternatives(expression, [], true)) {
-    const value = isConstAssertion(a) ? skipParentheses(getExpression(a)!) : a;
-    if (value.kind === SyntaxKind.ArrayLiteralExpression) arrays.push(value as ArrayLiteralExpression);
-  }
-  return arrays;
-}
-
-function isConstAssertion(node: Node): boolean {
-  return (
-    (node.kind === SyntaxKind.AsExpression || node.kind === SyntaxKind.TypeAssertionExpression) &&
-    isConstTypeReference(getType(node)!)
-  );
-}
-
-/**
- * The alternatives whose union each variable of a binding name is widened from, given the alternatives
- * of the iterated elements: all of them for an identifier; for an element of an array pattern, its
- * element of each `as const` array literal, or every element of another array literal; for an element
- * of an object pattern, the values of its property in each object literal.
- */
-function bindingAlternatives(name: Node, elements: Node[]): Node[][] {
-  if (name.kind === SyntaxKind.Identifier) return [elements];
-  const result: Node[][] = [];
-  const isArrayPattern = name.kind === SyntaxKind.ArrayBindingPattern;
-  const bindings = (name as BindingPattern).elements.nodes;
-  for (let k = 0; k < bindings.length; k++) {
-    const binding = bindings[k]!;
-    if (binding.kind !== SyntaxKind.BindingElement) continue;
-    const element = binding as BindingElement;
-    if (element.dotDotDotToken !== undefined || element.initializer !== undefined) continue;
-    if (element.name?.kind !== SyntaxKind.Identifier) continue;
-    const alternatives: Node[] = [];
-    if (isArrayPattern) {
-      for (const e of elements) {
-        const value = isConstAssertion(e) ? skipParentheses(getExpression(e)!) : e;
-        if (value.kind !== SyntaxKind.ArrayLiteralExpression) continue;
-        const array = value as ArrayLiteralExpression;
-        if (value !== e || isInConstAssertion(array)) {
-          const item = array.elements.nodes[k];
-          if (item !== undefined && item.kind !== SyntaxKind.SpreadElement) addAlternatives(item, alternatives, true);
-        } else addArrayElements(array, alternatives);
-      }
-    } else {
-      const property = element.propertyName ?? element.name;
-      const propertyName = property.kind === SyntaxKind.Identifier ? getText(property) : undefined;
-      if (propertyName === undefined) continue;
-      for (const e of elements) {
-        if (e.kind !== SyntaxKind.ObjectLiteralExpression) continue;
-        for (const member of (e as ObjectLiteralExpression).properties.nodes)
-          if (member.kind === SyntaxKind.PropertyAssignment && staticPropertyName(member) === propertyName)
-            addAlternatives((member as PropertyAssignment).initializer, alternatives, true);
-      }
-    }
-    if (alternatives.length !== 0) result.push(alternatives);
-  }
-  return result;
-}
-
-/** The name of an object literal member with a literal name. */
-function staticPropertyName(member: Node): string | undefined {
-  switch (member.kind) {
-    case SyntaxKind.PropertyAssignment:
-    case SyntaxKind.ShorthandPropertyAssignment:
-    case SyntaxKind.MethodDeclaration:
-    case SyntaxKind.GetAccessor:
-    case SyntaxKind.SetAccessor:
-      break;
-    default:
-      return undefined;
-  }
-  const name = getName(member)!;
-  switch (name.kind) {
-    case SyntaxKind.Identifier:
-    case SyntaxKind.StringLiteral:
-    case SyntaxKind.NoSubstitutionTemplateLiteral:
-      return getText(name);
-    case SyntaxKind.NumericLiteral:
-      return String(Number(getText(name)));
-  }
-  return undefined;
-}
-
 function getPropertiesOfContext(c: Checker, context: WideningContext): Symbol[] {
   if (context.resolvedProperties === undefined) {
     const names = new Map<string, Symbol>();
@@ -1852,11 +932,11 @@ export function isReadonlySymbol(c: Checker, symbol: Symbol): boolean {
       (getDeclarationNodeFlagsFromSymbol(symbol) & NodeFlags.Constant) !== 0) ||
     ((symbol.flags & SymbolFlags.Accessor) !== 0 && (symbol.flags & SymbolFlags.SetAccessor) === 0) ||
     (symbol.flags & SymbolFlags.EnumMember) !== 0 ||
-    someReadonlyAssignmentDeclaration(c, symbol.declarations)
+    someReadonlyAssignmentDeclaration(c, getDeclarations(symbol))
   );
 }
 
-function someReadonlyAssignmentDeclaration(c: Checker, declarations: Node[]): boolean {
+function someReadonlyAssignmentDeclaration(c: Checker, declarations: readonly Node[]): boolean {
   for (const d of declarations) if (isReadonlyAssignmentDeclaration(c, d)) return true;
   return false;
 }
@@ -1887,7 +967,7 @@ import {
 } from './checker-members.js';
 import { checkExpression } from './checker-expressions.js';
 import { getParameterTypeOfFullSignature } from './checker-jsdoc.js';
-import { isFunctionLike, isFunctionLikeDeclarationKind, isInJSFile } from './ast-utilities.js';
+import { isFunctionLikeDeclarationKind, isInJSFile } from './ast-utilities.js';
 import { isEmptyArrayLiteralType } from './relations.js';
 import { isCheckJsEnabledForFile } from './program-utilities.js';
 
@@ -1920,7 +1000,7 @@ function getAnnotatedAccessorType(c: Checker, accessor: Node | undefined): Type
 
 /** The `accessor` property declaration of `symbol`, if any. */
 function getAutoAccessorDeclaration(symbol: Symbol): Node | undefined {
-  for (const d of symbol.declarations)
+  for (const d of getDeclarations(symbol))
     if (d.kind === SyntaxKind.PropertyDeclaration && (getCombinedModifierFlags(d) & ModifierFlags.Accessor) !== 0)
       return d;
   return undefined;
@@ -1931,8 +1011,8 @@ function getTypeOfAccessors(c: Checker, symbol: Symbol): Type {
   const type = c.symbolTypes.get(id);
   if (type !== undefined) return type;
   if (!pushTypeResolution(c, symbol, TypeSystemPropertyName.Type)) return c.errorType;
-  const getter = symbol.declarations.find((d) => d.kind === SyntaxKind.GetAccessor);
-  const setter = symbol.declarations.find((d) => d.kind === SyntaxKind.SetAccessor);
+  const getter = getDeclarations(symbol).find((d) => d.kind === SyntaxKind.GetAccessor);
+  const setter = getDeclarations(symbol).find((d) => d.kind === SyntaxKind.SetAccessor);
   const accessor = getAutoAccessorDeclaration(symbol);
   // Getter annotation, setter annotation, accessor annotation, then getter body.
   let t =
@@ -1994,7 +1074,7 @@ export function getWriteTypeOfAccessors(c: Checker, symbol: Symbol): Type {
   if (links.writeType !== undefined) return links.writeType;
   if (!pushTypeResolution(c, symbol, TypeSystemPropertyName.WriteType)) return c.errorType;
   const setter =
-    symbol.declarations.find((d) => d.kind === SyntaxKind.SetAccessor) ?? getAutoAccessorDeclaration(symbol);
+    getDeclarations(symbol).find((d) => d.kind === SyntaxKind.SetAccessor) ?? getAutoAccessorDeclaration(symbol);
   let writeType = getAnnotatedAccessorType(c, setter);
   if (!popTypeResolution(c)) {
     if (getAnnotatedAccessorTypeNode(setter) !== undefined)