tsc-ts 0.0.5 → 0.0.7

package/src/compiler/checker-modules.ts

@@ -112,7 +112,6 @@ import {
   tryExtractTSExtension,
   tryGetExtensionFromPath,
 } from './path.js';
-import { InternalSymbolName, type Symbol, SymbolFlags, type SymbolTable, getSymbolId } from './symbol.js';
 import { SyntaxKind } from './syntax-kind.js';
 import { isExpressionNode } from './transformers/alias-references.js';
 import { type Checker, type CheckerHost, createDiagnosticForNode } from './checker.js';
@@ -162,6 +161,17 @@ import { createPromiseType } from './checker-iteration.js';
 import { symbolToString, typeToString } from './type-printer.js';
 import { checkTypeAssignableToAndOptionallyElaborate } from './checker-expressions.js';
 import { grammarErrorOnNode } from './checker-operators.js';
+import {
+  declarationAt,
+  declarationCount,
+  getDeclarations,
+  getSymbolId,
+  InternalSymbolName,
+  setDeclarations,
+  type Symbol,
+  SymbolFlags,
+  type SymbolTable,
+} from './symbol.js';
 
 // ---- Resolution
 
@@ -216,6 +226,22 @@ export function resolveExternalModuleNameWorker(
   );
 }
 
+/** A `resolveExternalModule` result that reported nothing, and the arguments it was computed for. */
+export class ModuleResolution {
+  constructor(
+    readonly moduleReference: string,
+    readonly moduleNotFoundError: DiagnosticMessage | undefined,
+    readonly isForAugmentation: boolean,
+    readonly symbol: Symbol | undefined,
+  ) {}
+}
+
+/**
+ * The module symbol `moduleReference` resolves to from `location`, reporting resolution errors at
+ * `errorNode`. Each name an import or export declaration lists resolves its module specifier again,
+ * with the same result and the same diagnostics: a result that reported nothing is kept for the
+ * specifier and returned to later calls from the same declaration (`sharesSpecifierContext`).
+ */
 export function resolveExternalModule(
   c: Checker,
   location: Node,
@@ -223,6 +249,80 @@ export function resolveExternalModule(
   moduleNotFoundError: DiagnosticMessage | undefined,
   errorNode: Node | undefined,
   isForAugmentation: boolean,
+): Symbol | undefined {
+  // An augmentation merged later can give the resolved module a new merged symbol, so results are
+  // kept only once every augmentation is merged.
+  const shared = c.modulesMerged && errorNode !== undefined && sharesSpecifierContext(location, errorNode);
+  if (shared) {
+    const known = c.moduleResolutions.get(errorNode);
+    if (
+      known !== undefined &&
+      known.moduleReference === moduleReference &&
+      known.moduleNotFoundError === moduleNotFoundError &&
+      known.isForAugmentation === isForAugmentation
+    )
+      return known.symbol;
+  }
+  const reports = c.reports;
+  const symbol = resolveExternalModuleWorker(
+    c,
+    location,
+    moduleReference,
+    moduleNotFoundError,
+    errorNode,
+    isForAugmentation,
+  );
+  if (shared && c.reports === reports)
+    c.moduleResolutions.set(
+      errorNode,
+      new ModuleResolution(moduleReference, moduleNotFoundError, isForAugmentation, symbol),
+    );
+  return symbol;
+}
+
+/**
+ * Whether a resolution from `location` with errors at `errorNode` depends on `location` only through
+ * the declaration that `errorNode` is the module specifier of: `location` is that declaration, a
+ * clause or specifier inside it, or the specifier itself. The resolution mode, the emittability of
+ * the import and its resolution-mode attributes then all come from that declaration.
+ */
+function sharesSpecifierContext(location: Node, errorNode: Node): boolean {
+  const declaration = errorNode.parent;
+  if (
+    declaration === undefined ||
+    (declaration.kind !== SyntaxKind.ImportDeclaration &&
+      declaration.kind !== SyntaxKind.JSImportDeclaration &&
+      declaration.kind !== SyntaxKind.ExportDeclaration) ||
+    getModuleSpecifier(declaration) !== errorNode
+  )
+    return false;
+  for (let current: Node | undefined = location; current !== undefined; current = current.parent)
+    switch (current.kind) {
+      case SyntaxKind.ImportDeclaration:
+      case SyntaxKind.JSImportDeclaration:
+      case SyntaxKind.ExportDeclaration:
+        return current === declaration;
+      case SyntaxKind.ImportClause:
+      case SyntaxKind.NamedImports:
+      case SyntaxKind.NamespaceImport:
+      case SyntaxKind.ImportSpecifier:
+      case SyntaxKind.NamedExports:
+      case SyntaxKind.NamespaceExport:
+      case SyntaxKind.ExportSpecifier:
+        break;
+      default:
+        if (current !== errorNode) return false;
+    }
+  return false;
+}
+
+function resolveExternalModuleWorker(
+  c: Checker,
+  location: Node,
+  moduleReference: string,
+  moduleNotFoundError: DiagnosticMessage | undefined,
+  errorNode: Node | undefined,
+  isForAugmentation: boolean,
 ): Symbol | undefined {
   if (errorNode !== undefined && moduleReference.startsWith('@types/'))
     c.error(
@@ -779,7 +879,8 @@ function isOnlyImportableAsDefault(c: Checker, usage: Node, resolvedModule: Symb
   const targetFile = moduleSymbol !== undefined ? getSourceFileOfModuleSymbol(moduleSymbol) : undefined;
   return (
     targetFile !== undefined &&
-    (isJsonSourceFile(targetFile) || getDeclarationFileExtension(targetFile.fileName) === '.d.json.ts')
+    (isJsonSourceFile(targetFile) ||
+      (targetFile.fileName.endsWith('.d.json.ts') && getDeclarationFileExtension(targetFile.fileName) === '.d.json.ts'))
   );
 }
 
@@ -787,7 +888,7 @@ function isOnlyImportableAsDefault(c: Checker, usage: Node, resolvedModule: Symb
 function getSourceFileOfModuleSymbol(symbol: Symbol): SourceFile | undefined {
   let declaration = symbol.valueDeclaration;
   if (declaration === undefined)
-    for (const d of symbol.declarations)
+    for (const d of getDeclarations(symbol))
       if (!(isAmbientModule(d) && isModuleAugmentationExternal(d)) && !isGlobalScopeAugmentation(d)) {
         declaration = d;
         break;
@@ -857,7 +958,7 @@ function createDefaultPropertyWrapperForModule(
 
 function cloneTypeAsModuleType(c: Checker, symbol: Symbol, moduleType: Type): Symbol {
   const result = c.newSymbol(symbol.flags, symbol.name);
-  result.declarations = symbol.declarations.slice();
+  setDeclarations(result, getDeclarations(symbol).slice());
   result.valueDeclaration = symbol.valueDeclaration;
   if (symbol.members !== undefined) result.members = new Map(symbol.members);
   if (symbol.exports !== undefined) result.exports = new Map(symbol.exports);
@@ -869,7 +970,7 @@ function cloneTypeAsModuleType(c: Checker, symbol: Symbol, moduleType: Type): Sy
 
 function getSourceFileDeclaration(symbol: Symbol | undefined): SourceFile | undefined {
   if (symbol === undefined) return undefined;
-  for (const d of symbol.declarations) if (d.kind === SyntaxKind.SourceFile) return d as SourceFile;
+  for (const d of getDeclarations(symbol)) if (d.kind === SyntaxKind.SourceFile) return d as SourceFile;
   return undefined;
 }
 
@@ -919,7 +1020,7 @@ function canHaveSyntheticDefault(
 }
 
 function hasSyntacticDefault(symbol: Symbol): boolean {
-  for (const d of symbol.declarations) if (isSyntacticDefault(d)) return true;
+  for (const d of getDeclarations(symbol)) if (isSyntacticDefault(d)) return true;
   return false;
 }
 
@@ -1154,7 +1255,7 @@ function reportNonDefaultExport(c: Checker, moduleSymbol: Symbol, node: Node): v
   );
   const exportStar = moduleSymbol.exports?.get(InternalSymbolName.ExportStar);
   if (exportStar === undefined) return;
-  for (const d of exportStar.declarations) {
+  for (const d of getDeclarations(exportStar)) {
     const specifier = getModuleSpecifier(d);
     if (d.kind !== SyntaxKind.ExportDeclaration || specifier === undefined) continue;
     const resolved = resolveExternalModuleName(c, d, specifier, false);
@@ -1304,9 +1405,9 @@ function combineValueAndTypeSymbols(c: Checker, valueSymbol: Symbol, typeSymbol:
   if ((typeSymbol.flags & SymbolFlags.Value) !== 0) return typeSymbol;
   if ((valueSymbol.flags & (SymbolFlags.Type | SymbolFlags.Namespace)) !== 0) return valueSymbol;
   const result = c.newSymbol(valueSymbol.flags | typeSymbol.flags, valueSymbol.name);
-  const declarations = valueSymbol.declarations.slice();
-  for (const d of typeSymbol.declarations) if (!declarations.includes(d)) declarations.push(d);
-  result.declarations = declarations;
+  const declarations = getDeclarations(valueSymbol).slice();
+  for (const d of getDeclarations(typeSymbol)) if (!declarations.includes(d)) declarations.push(d);
+  setDeclarations(result, declarations);
   result.parent = valueSymbol.parent ?? typeSymbol.parent;
   result.valueDeclaration = valueSymbol.valueDeclaration;
   if (typeSymbol.members !== undefined) result.members = new Map(typeSymbol.members);
@@ -1412,10 +1513,10 @@ function reportNonExportedMember(
           symbolToString(c, exportedSymbol),
         )
       : c.error(name, Diagnostics.Module_0_declares_1_locally_but_it_is_not_exported, moduleName, declarationName);
-  for (let i = 0; i < localSymbol.declarations.length; i++)
+  for (let i = 0; i < declarationCount(localSymbol); i++)
     diagnostic.addRelatedInfo(
       createDiagnosticForNode(
-        localSymbol.declarations[i]!,
+        declarationAt(localSymbol, i),
         i === 0 ? Diagnostics.X_0_is_declared_here : Diagnostics.X_and_here,
         [declarationName],
       ),
@@ -1985,7 +2086,7 @@ class ExportCollector {
     if (exportStars !== undefined) {
       const nested: SymbolTable = new Map<string, Symbol>();
       const lookupTable = new Map<string, ExportCollision>();
-      for (const node of exportStars.declarations) {
+      for (const node of getDeclarations(exportStars)) {
         const specifier = (node as ExportDeclaration).moduleSpecifier;
         const resolved = resolveExternalModuleName(this.c, node, specifier, false);
         const exported = this.visit(resolved, node, isTypeOnly || getIsTypeOnly(node));
@@ -2551,7 +2652,7 @@ function checkExportSpecifier(c: Checker, node: Node): void {
     symbol !== undefined &&
     (symbol === c.undefinedSymbol ||
       symbol === c.globalThisSymbol ||
-      (symbol.declarations.length > 0 && isGlobalSourceFile(getDeclarationContainer(symbol.declarations[0]!))))
+      (declarationCount(symbol) > 0 && isGlobalSourceFile(getDeclarationContainer(symbol.declaration!))))
   )
     c.error(
       exportedName,

package/src/compiler/checker-object-literals.ts

@@ -16,7 +16,6 @@ import {
 import { isAssignmentTarget } from './binder-utilities.js';
 import { createDiagnosticForNode, type Checker } from './checker.js';
 import { Diagnostics } from './diagnostics.js';
-import { CheckFlags, type Symbol, SymbolFlags, internalSymbolNamePrefix, getSymbolId } from './symbol.js';
 import { SyntaxKind } from './syntax-kind.js';
 import {
   CheckMode,
@@ -46,6 +45,8 @@ import {
   getPropertiesOfType,
   getPropertyOfType,
   getReducedType,
+  keepPropertiesOnly,
+  scannedLiteralPropertiesLimit,
 } from './checker-members.js';
 import { symbolToString, typeToString } from './type-printer.js';
 import { getMergedSymbol, getSymbolOfDeclaration } from './checker-symbols.js';
@@ -76,6 +77,17 @@ import {
 import { addIntraExpressionInferenceSite } from './checker-inference.js';
 import { isEmptyObjectType } from './checker-type-factory.js';
 import { getTypeOfExpandoObjectLiteral, isJSObjectLiteral } from './checker-javascript.js';
+import {
+  CheckFlags,
+  copyDeclarations,
+  declarationCount,
+  getDeclarations,
+  getSymbolId,
+  internalSymbolNamePrefix,
+  setDeclarations,
+  type Symbol,
+  SymbolFlags,
+} from './symbol.js';
 
 /** Builds the type of the members collected since the last spread. */
 class ObjectLiteralBuilder {
@@ -123,6 +135,8 @@ class ObjectLiteralBuilder {
     if (this.patternWithComputedProperties)
       result.objectFlags |= ObjectFlags.ObjectLiteralPatternWithComputedProperties;
     if (this.inDestructuringPattern) c.patternForType.set(result, this.node);
+    // A literal of a few properties keeps them as a list; a lookup by name compares their names.
+    keepPropertiesOnly(c, result, this.members, scannedLiteralPropertiesLimit);
     return result;
   }
 
@@ -229,7 +243,7 @@ export function checkObjectLiteral(c: Checker, node: Node, checkMode: CheckMode)
             typeToString(c, contextualType!),
           );
       }
-      prop.declarations = member.declarations;
+      copyDeclarations(prop, member);
       prop.parent = member.parent;
       prop.valueDeclaration = member.valueDeclaration;
       c.symbolTypes.set(id, t);
@@ -317,7 +331,7 @@ function getObjectLiteralIndexInfo(c: Checker, isReadonly: boolean, properties:
       (keyType === c.esSymbolType && isSymbolWithSymbolName(c, prop))
     ) {
       propTypes.push(getTypeOfSymbol(c, prop));
-      if (isSymbolWithComputedName(prop)) components.push(prop.declarations[0]!);
+      if (isSymbolWithComputedName(prop)) components.push(prop.declaration!);
     }
   }
   const unionType =
@@ -328,7 +342,7 @@ function getObjectLiteralIndexInfo(c: Checker, isReadonly: boolean, properties:
 }
 
 function getFirstDeclarationName(symbol: Symbol): Node | undefined {
-  return symbol.declarations.length !== 0 ? getName(symbol.declarations[0]!) : undefined;
+  return declarationCount(symbol) !== 0 ? getName(symbol.declaration!) : undefined;
 }
 
 function isSymbolWithSymbolName(c: Checker, symbol: Symbol): boolean {
@@ -470,7 +484,7 @@ export function getSpreadType(
     );
     c.symbolLeftSpreads.set(id, leftProp);
     c.symbolRightSpreads.set(id, rightProp);
-    result.declarations = leftProp.declarations.concat(rightProp.declarations);
+    setDeclarations(result, getDeclarations(leftProp).concat(getDeclarations(rightProp)));
     c.symbolNameTypes.set(id, c.symbolNameTypes.get(getSymbolId(leftProp)));
     members.set(leftProp.name, result);
   }
@@ -479,6 +493,7 @@ export function getSpreadType(
   const spread = createAnonymousType(c, symbol, members, [], [], spreadIndexInfos);
   spread.objectFlags |=
     ObjectFlags.ObjectLiteral | ObjectFlags.ContainsObjectOrArrayLiteral | ObjectFlags.ContainsSpread | objectFlags;
+  keepPropertiesOnly(c, spread, members, scannedLiteralPropertiesLimit);
   return spread;
 }
 
@@ -564,12 +579,13 @@ function tryMergeUnionOfObjectTypeAndEmptyObject(c: Checker, t: Type, readonly:
       id,
       isSetonlyAccessor ? c.undefinedType : addOptionality(c, getTypeOfSymbol(c, prop), true, true),
     );
-    result.declarations = prop.declarations;
+    copyDeclarations(result, prop);
     c.symbolNameTypes.set(id, c.symbolNameTypes.get(getSymbolId(prop)));
     c.symbolSyntheticOrigins.set(id, prop);
     members.set(prop.name, result);
   }
   const spread = createAnonymousType(c, firstType.symbol, members, [], [], getIndexInfosOfType(c, firstType));
   spread.objectFlags |= ObjectFlags.ObjectLiteral | ObjectFlags.ContainsObjectOrArrayLiteral;
+  keepPropertiesOnly(c, spread, members, scannedLiteralPropertiesLimit);
   return spread;
 }

package/src/compiler/checker-overloads.ts

@@ -23,7 +23,6 @@ import {
 } from './binder-utilities.js';
 import { nodeIsMissing, nodeIsPresent } from './ast-utilities.js';
 import { type DiagnosticMessage, Diagnostics } from './diagnostics.js';
-import { type Symbol, SymbolFlags } from './symbol.js';
 import { SyntaxKind } from './syntax-kind.js';
 import { type Checker, createDiagnosticForNode } from './checker.js';
 import type { Signature } from './checker-types.js';
@@ -39,6 +38,7 @@ import { checkComputedPropertyName } from './checker-expressions.js';
 import { hasDynamicName, hasLateBindableName } from './checker-utilities.js';
 import { isSignatureAssignableTo, isTypeIdenticalTo, isTypeRelatedTo } from './relations.js';
 import { getEffectiveDeclarationFlags } from './checker-declarations.js';
+import { getDeclarations, type Symbol, SymbolFlags } from './symbol.js';
 
 /** Checks the overloads of a function or method declaration's local and export symbols. */
 export function checkFunctionOrMethodSymbols(c: Checker, node: Node): void {
@@ -84,7 +84,7 @@ class OverloadChecker {
 
   check(): void {
     const c = this.c;
-    const declarations = this.symbol.declarations;
+    const declarations = getDeclarations(this.symbol);
     let someNodeFlags = ModifierFlags.None;
     let allNodeFlags = flagsToCheck();
     let someHaveQuestionToken = false;
@@ -184,8 +184,8 @@ class OverloadChecker {
   reportClassMergedWithFunction(): void {
     const c = this.c;
     const classes: Node[] = [];
-    for (const d of this.symbol.declarations) if (d.kind === SyntaxKind.ClassDeclaration) classes.push(d);
-    for (const d of this.symbol.declarations) {
+    for (const d of getDeclarations(this.symbol)) if (d.kind === SyntaxKind.ClassDeclaration) classes.push(d);
+    for (const d of getDeclarations(this.symbol)) {
       let message: DiagnosticMessage;
       if (d.kind === SyntaxKind.ClassDeclaration)
         message = Diagnostics.Class_declaration_cannot_implement_overload_list_for_0;
@@ -201,7 +201,7 @@ class OverloadChecker {
   }
 
   checkFlagAgreement(
-    overloads: Node[],
+    overloads: readonly Node[],
     implementation: Node | undefined,
     someOverloadFlags: ModifierFlags,
     allOverloadFlags: ModifierFlags,
@@ -290,7 +290,7 @@ class OverloadChecker {
  * The declaration whose flags overloads must agree with: the implementation when it shares the first
  * overload's container (so overloads from other files aren't reported), else the first overload.
  */
-function getCanonicalOverload(overloads: Node[], implementation: Node | undefined): Node {
+function getCanonicalOverload(overloads: readonly Node[], implementation: Node | undefined): Node {
   return implementation !== undefined && implementation.parent === overloads[0]!.parent
     ? implementation
     : overloads[0]!;

package/src/compiler/checker-property-access.ts

@@ -37,7 +37,6 @@ import {
 import { isFunctionLike, isInJSFile } from './ast-utilities.js';
 import { type Checker, createDiagnosticForNode } from './checker.js';
 import { type Diagnostic, Diagnostics } from './diagnostics.js';
-import { CheckFlags, type Symbol, SymbolFlags, getSymbolId } from './symbol.js';
 import { SyntaxKind } from './syntax-kind.js';
 import {
   CheckMode,
@@ -102,6 +101,7 @@ import {
   getResolvedSymbol,
 } from './checker-expressions.js';
 import { isJSLiteralType, isThisPropertyAccessInConstructor } from './checker-javascript.js';
+import { CheckFlags, getDeclarations, getSymbolId, type Symbol, SymbolFlags } from './symbol.js';
 
 export function checkPropertyAccessExpressionOrQualifiedName(
   c: Checker,
@@ -607,7 +607,7 @@ function checkPropertyAccessibilityAtLocation(
 }
 
 function hasClassInstancePropertyDeclaration(symbol: Symbol): boolean {
-  for (const d of symbol.declarations) if (isClassInstanceProperty(d)) return true;
+  for (const d of getDeclarations(symbol)) if (isClassInstanceProperty(d)) return true;
   return false;
 }
 

package/src/compiler/checker-services.ts

@@ -126,7 +126,7 @@ import {
 } from './checker-type-nodes.js';
 import { CheckMode, type Signature, type Type } from './checker-types.js';
 import { getNodeAtPosition } from './parser.js';
-import { CheckFlags, InternalSymbolName, type Symbol, SymbolFlags, getSymbolId } from './symbol.js';
+import { CheckFlags, getSymbolId, InternalSymbolName, setDeclarations, type Symbol, SymbolFlags } from './symbol.js';
 import { SyntaxKind } from './syntax-kind.js';
 
 // ---- Symbols at locations
@@ -397,7 +397,7 @@ function getApplicableIndexSymbol(c: Checker, t: Type, keyType: Type): Symbol |
           declarations.push(other.declaration);
     if (declarations.length !== 0) {
       const symbol = c.newSymbolWithCheckFlags(SymbolFlags.Property, InternalSymbolName.Index, CheckFlags.IndexSymbol);
-      symbol.declarations = declarations;
+      setDeclarations(symbol, declarations);
       symbol.valueDeclaration = declarations[0]!;
       symbol.parent = t.symbol;
       c.symbolTypes.set(getSymbolId(symbol), info.valueType);

package/src/compiler/checker-signatures.ts

@@ -30,7 +30,6 @@ import {
   getDeclarationOfKind,
 } from './binder-utilities.js';
 import { Diagnostics } from './diagnostics.js';
-import { InternalSymbolName, type Symbol, SymbolFlags } from './symbol.js';
 import { SyntaxKind } from './syntax-kind.js';
 import type { Checker } from './checker.js';
 import {
@@ -111,6 +110,7 @@ import { isTypeAssignableTo, type TypeComparer } from './relations.js';
 import { getReturnTypeFromBody, getTypePredicateFromBody } from './checker-functions.js';
 import { checkComputedPropertyName } from './checker-expressions.js';
 import { hasLateBindableIndexSignature } from './checker-utilities.js';
+import { declarationCount, getDeclarations, InternalSymbolName, type Symbol, SymbolFlags } from './symbol.js';
 
 // ---- From declarations
 
@@ -118,7 +118,7 @@ import { hasLateBindableIndexSignature } from './checker-utilities.js';
 export function getSignaturesOfSymbol(c: Checker, symbol: Symbol | undefined): Signature[] {
   if (symbol === undefined) return [];
   const result: Signature[] = [];
-  const declarations = symbol.declarations;
+  const declarations = getDeclarations(symbol);
   for (let i = 0; i < declarations.length; i++) {
     const decl = declarations[i]!;
     if (!isFunctionLikeNode(decl)) continue;
@@ -362,7 +362,7 @@ export function getReturnTypeFromAnnotation(c: Checker, declaration: Node): Type
   if (declaration.kind === SyntaxKind.GetAccessor) {
     const symbol = getSymbolOfDeclaration(c, declaration);
     if (symbol !== undefined) {
-      const setter = symbol.declarations.find((d) => d.kind === SyntaxKind.SetAccessor);
+      const setter = getDeclarations(symbol).find((d) => d.kind === SyntaxKind.SetAccessor);
       if (setter !== undefined) {
         const parameters = getParameters(setter);
         if (parameters !== undefined) {
@@ -898,7 +898,7 @@ export function getIndexInfosOfIndexSymbol(c: Checker, indexSymbol: Symbol, sibl
   let readonlyNumber = true;
   let readonlySymbol = true;
   const propertySymbols: Symbol[] = [];
-  for (const declaration of indexSymbol.declarations) {
+  for (const declaration of getDeclarations(indexSymbol)) {
     if (declaration.kind === SyntaxKind.IndexSignature) {
       const parameters = getParameters(declaration)?.nodes ?? [];
       const returnTypeNode = getType(declaration);
@@ -952,7 +952,7 @@ import { ContextFlags, getContextualTypeEx } from './checker-contextual.js';
 /** Whether `symbol` is a known symbol or has a computed name of a symbol type. */
 function isSymbolWithSymbolName(c: Checker, symbol: Symbol): boolean {
   if (symbol.name.startsWith('\ufffe@')) return true;
-  const name = symbol.declarations.length !== 0 ? getName(symbol.declarations[0]!) : undefined;
+  const name = declarationCount(symbol) !== 0 ? getName(symbol.declaration!) : undefined;
   return (
     name !== undefined &&
     name.kind === SyntaxKind.ComputedPropertyName &&
@@ -963,7 +963,7 @@ function isSymbolWithSymbolName(c: Checker, symbol: Symbol): boolean {
 /** Whether `symbol` has a numeric name, or a computed name of a number type. */
 function isSymbolWithNumericName(c: Checker, symbol: Symbol): boolean {
   if (isNumericLiteralName(symbol.name)) return true;
-  const name = symbol.declarations.length !== 0 ? getName(symbol.declarations[0]!) : undefined;
+  const name = declarationCount(symbol) !== 0 ? getName(symbol.declaration!) : undefined;
   if (name === undefined) return false;
   if (name.kind === SyntaxKind.ComputedPropertyName)
     return isTypeAssignableToKind(c, checkComputedPropertyName(c, name), TypeFlags.NumberLike);
@@ -985,7 +985,7 @@ function getObjectLiteralIndexInfo(c: Checker, isReadonly: boolean, properties:
       (keyType === c.esSymbolType && isSymbolWithSymbolName(c, prop))
     ) {
       propTypes.push(getTypeOfSymbol(c, prop));
-      if (isSymbolWithComputedName(prop)) components.push(prop.declarations[0]!);
+      if (isSymbolWithComputedName(prop)) components.push(prop.declaration!);
     }
   }
   const unionType =
@@ -996,8 +996,8 @@ function getObjectLiteralIndexInfo(c: Checker, isReadonly: boolean, properties:
 }
 
 function isSymbolWithComputedName(symbol: Symbol): boolean {
-  if (symbol.declarations.length === 0) return false;
-  const name = getName(symbol.declarations[0]!);
+  if (declarationCount(symbol) === 0) return false;
+  const name = getName(symbol.declaration!);
   return name !== undefined && name.kind === SyntaxKind.ComputedPropertyName;
 }