tsc-ts 0.0.6 → 0.0.8

package/src/compiler/ast.ts

@@ -4075,9 +4075,45 @@ export class ElementAccessExpression extends Node {
 
 export class CallExpression extends Node {
   expression: Expression;
+  arguments: NodeList;
+
+  constructor(expression: Expression, args: NodeList, flags: NodeFlags) {
+    super(SyntaxKind.CallExpression);
+    this.expression = expression;
+    this.arguments = args;
+    this.flags |= flags & NodeFlags.OptionalChain;
+  }
+
+  forEachChild(v: NodeVisitor): boolean {
+    if (v.visitNode(this.expression)) return true;
+    return v.visitList(this.arguments);
+  }
+
+  setParentOfChildren(): void {
+    this.expression.parent = this;
+    setParents(this.arguments.nodes, this);
+  }
+
+  deepClone(): Node {
+    return this.copy();
+  }
+
+  copy(): CallExpression {
+    const node = new CallExpression(this.expression.deepClone(), cloneList(this.arguments), this.flags);
+    node.flags = this.flags;
+    node.pos = this.pos;
+    node.end = this.end;
+    return node;
+  }
+}
+
+/**
+ * A call with `?.` or type arguments, or in a JavaScript file, where the binder can declare a symbol
+ * for it (`Object.defineProperty`). Other calls are a plain `CallExpression`, without these fields.
+ */
+export class FullCallExpression extends CallExpression {
   questionDotToken: Token | undefined;
   typeArguments: NodeList | undefined;
-  arguments: NodeList;
   // Set by the binder.
   symbol: Symbol | undefined;
 
@@ -4088,12 +4124,9 @@ export class CallExpression extends Node {
     args: NodeList,
     flags: NodeFlags,
   ) {
-    super(SyntaxKind.CallExpression);
-    this.expression = expression;
+    super(expression, args, flags);
     this.questionDotToken = questionDotToken;
     this.typeArguments = typeArguments;
-    this.arguments = args;
-    this.flags |= flags & NodeFlags.OptionalChain;
     this.symbol = undefined;
   }
 
@@ -4111,12 +4144,8 @@ export class CallExpression extends Node {
     setParents(this.arguments.nodes, this);
   }
 
-  deepClone(): Node {
-    return this.copy();
-  }
-
   copy(): CallExpression {
-    const node = new CallExpression(
+    const node = new FullCallExpression(
       this.expression.deepClone(),
       this.questionDotToken === undefined ? undefined : this.questionDotToken.copy(),
       this.typeArguments === undefined ? undefined : cloneList(this.typeArguments),
@@ -4130,6 +4159,28 @@ export class CallExpression extends Node {
   }
 }
 
+/** A `FullCallExpression` when one of its fields is set or `inJavaScript`, else a `CallExpression`. */
+export function newCallExpression(
+  expression: Expression,
+  questionDotToken: Token | undefined,
+  typeArguments: NodeList | undefined,
+  args: NodeList,
+  flags: NodeFlags,
+  inJavaScript: boolean,
+): CallExpression {
+  if (inJavaScript || questionDotToken !== undefined || typeArguments !== undefined)
+    return new FullCallExpression(expression, questionDotToken, typeArguments, args, flags);
+  return new CallExpression(expression, args, flags);
+}
+
+export function callQuestionDotToken(node: CallExpression): Token | undefined {
+  return node instanceof FullCallExpression ? node.questionDotToken : undefined;
+}
+
+export function callTypeArguments(node: CallExpression): NodeList | undefined {
+  return node instanceof FullCallExpression ? node.typeArguments : undefined;
+}
+
 export class NewExpression extends Node {
   expression: Expression;
   typeArguments: NodeList | undefined;
@@ -4511,14 +4562,51 @@ export class SpreadAssignment extends Node {
 }
 
 export class PropertyAssignment extends Node {
-  modifiers: ModifierList | undefined;
   name: PropertyName;
-  postfixToken: Token | undefined;
-  type: TypeNode | undefined;
   initializer: Expression;
   // Set by the binder.
   symbol: Symbol | undefined;
 
+  constructor(name: PropertyName, initializer: Expression) {
+    super(SyntaxKind.PropertyAssignment);
+    this.name = name;
+    this.initializer = initializer;
+    this.symbol = undefined;
+  }
+
+  forEachChild(v: NodeVisitor): boolean {
+    if (v.visitNode(this.name)) return true;
+    return v.visitNode(this.initializer);
+  }
+
+  setParentOfChildren(): void {
+    this.name.parent = this;
+    this.initializer.parent = this;
+  }
+
+  deepClone(): Node {
+    return this.copy();
+  }
+
+  copy(): PropertyAssignment {
+    const node = new PropertyAssignment(this.name.deepClone(), this.initializer.deepClone());
+    node.flags = this.flags;
+    node.pos = this.pos;
+    node.end = this.end;
+    return node;
+  }
+}
+
+/**
+ * A property assignment with modifiers, a `?` or `!`, or a type annotation (which the grammar checker
+ * reports), or in a JavaScript file, where JSDoc can give it a type or modifiers. Other property
+ * assignments are a plain `PropertyAssignment`, without these fields.
+ */
+export class FullPropertyAssignment extends PropertyAssignment {
+  modifiers: ModifierList | undefined;
+  postfixToken: Token | undefined;
+  type: TypeNode | undefined;
+
   constructor(
     modifiers: ModifierList | undefined,
     name: PropertyName,
@@ -4526,13 +4614,10 @@ export class PropertyAssignment extends Node {
     type: TypeNode | undefined,
     initializer: Expression,
   ) {
-    super(SyntaxKind.PropertyAssignment);
+    super(name, initializer);
     this.modifiers = modifiers;
-    this.name = name;
     this.postfixToken = postfixToken;
     this.type = type;
-    this.initializer = initializer;
-    this.symbol = undefined;
   }
 
   forEachChild(v: NodeVisitor): boolean {
@@ -4551,12 +4636,8 @@ export class PropertyAssignment extends Node {
     this.initializer.parent = this;
   }
 
-  deepClone(): Node {
-    return this.copy();
-  }
-
   copy(): PropertyAssignment {
-    const node = new PropertyAssignment(
+    const node = new FullPropertyAssignment(
       this.modifiers === undefined ? undefined : cloneModifiers(this.modifiers),
       this.name.deepClone(),
       this.postfixToken === undefined ? undefined : this.postfixToken.copy(),
@@ -4570,6 +4651,32 @@ export class PropertyAssignment extends Node {
   }
 }
 
+/** A `FullPropertyAssignment` when one of its fields is set or `inJavaScript`, else a `PropertyAssignment`. */
+export function newPropertyAssignment(
+  modifiers: ModifierList | undefined,
+  name: PropertyName,
+  postfixToken: Token | undefined,
+  type: TypeNode | undefined,
+  initializer: Expression,
+  inJavaScript: boolean,
+): PropertyAssignment {
+  if (inJavaScript || modifiers !== undefined || postfixToken !== undefined || type !== undefined)
+    return new FullPropertyAssignment(modifiers, name, postfixToken, type, initializer);
+  return new PropertyAssignment(name, initializer);
+}
+
+export function propertyAssignmentModifiers(node: PropertyAssignment): ModifierList | undefined {
+  return node instanceof FullPropertyAssignment ? node.modifiers : undefined;
+}
+
+export function propertyAssignmentPostfixToken(node: PropertyAssignment): Token | undefined {
+  return node instanceof FullPropertyAssignment ? node.postfixToken : undefined;
+}
+
+export function propertyAssignmentType(node: PropertyAssignment): TypeNode | undefined {
+  return node instanceof FullPropertyAssignment ? node.type : undefined;
+}
+
 export class ShorthandPropertyAssignment extends Node {
   modifiers: ModifierList | undefined;
   name: PropertyName;
@@ -8109,6 +8216,24 @@ export class JSDocParameterOrPropertyTag extends Node {
   }
 }
 
+// The lists of a source file that has none. Most files have no diagnostics, references, pragmas
+// or ambient modules, so they share these instead of holding empty arrays of their own. A list
+// that grows replaces an empty one rather than pushing to it (appendToList).
+export const emptyDiagnostics: readonly Diagnostic[] = [];
+export const emptyNodes: readonly Node[] = [];
+export const emptyStrings: readonly string[] = [];
+export const emptyCommentDirectives: readonly CommentDirective[] = [];
+export const emptyPragmas: readonly Pragma[] = [];
+export const emptyFileReferences: readonly FileReference[] = [];
+export const emptyPatternAmbientModules: readonly PatternAmbientModule[] = [];
+
+/** `list` with `item` appended: a new array when `list` is empty (it may be shared), else `list` itself. */
+export function appendToList<T>(list: readonly T[], item: T): readonly T[] {
+  if (list.length === 0) return [item];
+  (list as T[]).push(item);
+  return list;
+}
+
 export class SourceFile extends Node {
   readonly fileName: string;
   readonly path: string;
@@ -8118,10 +8243,10 @@ export class SourceFile extends Node {
   endOfFileToken: Token;
 
   // Set by the parser.
-  diagnostics: Diagnostic[];
+  diagnostics: readonly Diagnostic[];
   /** Diagnostics for TypeScript-only syntax in JavaScript files. */
-  jsDiagnostics: Diagnostic[];
-  jsDocDiagnostics: Diagnostic[];
+  jsDiagnostics: readonly Diagnostic[];
+  jsDocDiagnostics: readonly Diagnostic[];
   languageVariant: LanguageVariant;
   scriptKind: ScriptKind;
   isDeclarationFile: boolean;
@@ -8136,20 +8261,20 @@ export class SourceFile extends Node {
   /** Module specifiers of imports, exports, `require` calls and `import()` types, in source order. */
   imports: Node[];
   /** Names of `declare module "x"` augmentations and `declare global` blocks in modules. */
-  moduleAugmentations: Node[];
-  ambientModuleNames: string[];
+  moduleAugmentations: readonly Node[];
+  ambientModuleNames: readonly string[];
   commentDirectives: readonly CommentDirective[];
-  pragmas: Pragma[];
-  referencedFiles: FileReference[];
-  typeReferenceDirectives: FileReference[];
-  libReferenceDirectives: FileReference[];
+  pragmas: readonly Pragma[];
+  referencedFiles: readonly FileReference[];
+  typeReferenceDirectives: readonly FileReference[];
+  libReferenceDirectives: readonly FileReference[];
   checkJsDirective: CheckJsDirective | undefined;
   /** The first CommonJS `module.exports`/`exports.x` use in a JavaScript file. */
   commonJSModuleIndicator: Node | undefined;
   /** What makes this file a module: an import or export statement, `import.meta`, a JSX tag, or the file itself when forced. */
   externalModuleIndicator: Node | undefined;
   /** Nodes cloned by JSDoc reparsing, sorted by position. */
-  reparsedClones: Node[];
+  reparsedClones: readonly Node[];
   /** Whether JSDoc of TypeScript files is parsed on first use. */
   hasLazyJSDoc: boolean;
   /**
@@ -8164,12 +8289,12 @@ export class SourceFile extends Node {
   locals: SymbolTable | undefined;
   nextContainer: Node | undefined;
   isBound: boolean;
-  bindDiagnostics: Diagnostic[];
+  bindDiagnostics: readonly Diagnostic[];
   /** The flow at the end of the file. */
   endFlowNode: FlowNode | undefined;
   symbolCount: number;
   /** Ambient modules with a `*` in their name, like `declare module "*.css"`. */
-  patternAmbientModules: PatternAmbientModule[];
+  patternAmbientModules: readonly PatternAmbientModule[];
   /** UMD exports from `export as namespace N`. */
   globalExports: SymbolTable | undefined;
 
@@ -8188,9 +8313,9 @@ export class SourceFile extends Node {
     this.externalModuleIndicatorOptions = externalModuleIndicatorOptions;
     this.statements = statements;
     this.endOfFileToken = endOfFileToken;
-    this.diagnostics = [];
-    this.jsDiagnostics = [];
-    this.jsDocDiagnostics = [];
+    this.diagnostics = emptyDiagnostics;
+    this.jsDiagnostics = emptyDiagnostics;
+    this.jsDocDiagnostics = emptyDiagnostics;
     this.languageVariant = 0;
     this.scriptKind = ScriptKind.Unknown;
     this.isDeclarationFile = false;
@@ -8201,17 +8326,17 @@ export class SourceFile extends Node {
     this.nodeCount = 0;
     this.textCount = 0;
     this.imports = [];
-    this.moduleAugmentations = [];
-    this.ambientModuleNames = [];
-    this.commentDirectives = [];
-    this.pragmas = [];
-    this.referencedFiles = [];
-    this.typeReferenceDirectives = [];
-    this.libReferenceDirectives = [];
+    this.moduleAugmentations = emptyNodes;
+    this.ambientModuleNames = emptyStrings;
+    this.commentDirectives = emptyCommentDirectives;
+    this.pragmas = emptyPragmas;
+    this.referencedFiles = emptyFileReferences;
+    this.typeReferenceDirectives = emptyFileReferences;
+    this.libReferenceDirectives = emptyFileReferences;
     this.checkJsDirective = undefined;
     this.commonJSModuleIndicator = undefined;
     this.externalModuleIndicator = undefined;
-    this.reparsedClones = [];
+    this.reparsedClones = emptyNodes;
     this.hasLazyJSDoc = false;
     this.jsDocs = undefined;
     this.diagnosticFileCache = undefined;
@@ -8219,10 +8344,10 @@ export class SourceFile extends Node {
     this.locals = undefined;
     this.nextContainer = undefined;
     this.isBound = false;
-    this.bindDiagnostics = [];
+    this.bindDiagnostics = emptyDiagnostics;
     this.endFlowNode = undefined;
     this.symbolCount = 0;
-    this.patternAmbientModules = [];
+    this.patternAmbientModules = emptyPatternAmbientModules;
     this.globalExports = undefined;
   }
 
@@ -8703,8 +8828,8 @@ export function getModifiers(node: Node): ModifierList | undefined {
       }
       break;
     case SyntaxKind.PropertyAssignment:
-      if (node instanceof PropertyAssignment) {
-        const holder: PropertyAssignment = node;
+      if (node instanceof FullPropertyAssignment) {
+        const holder: FullPropertyAssignment = node;
         return holder.modifiers;
       }
       break;
@@ -9077,8 +9202,8 @@ export function getType(node: Node): Node | undefined {
       }
       break;
     case SyntaxKind.PropertyAssignment:
-      if (node instanceof PropertyAssignment) {
-        const holder: PropertyAssignment = node;
+      if (node instanceof FullPropertyAssignment) {
+        const holder: FullPropertyAssignment = node;
         return holder.type;
       }
       break;
@@ -9566,8 +9691,8 @@ export function getPostfixToken(node: Node): Node | undefined {
       }
       break;
     case SyntaxKind.PropertyAssignment:
-      if (node instanceof PropertyAssignment) {
-        const holder: PropertyAssignment = node;
+      if (node instanceof FullPropertyAssignment) {
+        const holder: FullPropertyAssignment = node;
         return holder.postfixToken;
       }
       break;
@@ -9584,8 +9709,8 @@ export function getPostfixToken(node: Node): Node | undefined {
 export function getTypeArguments(node: Node): NodeList | undefined {
   switch (node.kind) {
     case SyntaxKind.CallExpression:
-      if (node instanceof CallExpression) {
-        const holder: CallExpression = node;
+      if (node instanceof FullCallExpression) {
+        const holder: FullCallExpression = node;
         return holder.typeArguments;
       }
       break;
@@ -10839,8 +10964,8 @@ export function getSymbol(node: Node): Symbol | undefined {
       }
       break;
     case SyntaxKind.CallExpression:
-      if (node instanceof CallExpression) {
-        const holder: CallExpression = node;
+      if (node instanceof FullCallExpression) {
+        const holder: FullCallExpression = node;
         return holder.symbol;
       }
       break;
@@ -11171,8 +11296,8 @@ export function setSymbol(node: Node, value: Symbol | undefined): void {
       }
       break;
     case SyntaxKind.CallExpression:
-      if (node instanceof CallExpression) {
-        const target: CallExpression = node;
+      if (node instanceof FullCallExpression) {
+        const target: FullCallExpression = node;
         target.symbol = value;
       }
       break;

package/src/compiler/binder-utilities.ts

@@ -47,6 +47,7 @@ import {
   getTagName,
   getText,
   getType,
+  callQuestionDotToken,
 } from './ast.js';
 import { getJSDoc } from './parser.js';
 import { isAssignmentOperator, isLeftHandSideExpression, isStringLiteralLike, nodeIsMissing } from './ast-utilities.js';
@@ -343,7 +344,7 @@ export function skipParentheses(node: Node): Node {
 function getQuestionDotToken(node: Node): Node | undefined {
   if (node instanceof PropertyAccessExpression) return (node as PropertyAccessExpression).questionDotToken;
   if (node instanceof ElementAccessExpression) return (node as ElementAccessExpression).questionDotToken;
-  if (node instanceof CallExpression) return (node as CallExpression).questionDotToken;
+  if (node instanceof CallExpression) return callQuestionDotToken(node as CallExpression);
   if (node instanceof TaggedTemplateExpression) return (node as TaggedTemplateExpression).questionDotToken;
   return undefined;
 }

package/src/compiler/binder.ts

@@ -4,6 +4,7 @@
 // Fields of `instanceof`-narrowed nodes are read through `as` casts: scriptc reads them
 // statically, but reads fields of a narrowed value dynamically.
 import {
+  appendToList,
   BinaryExpression,
   BindingElement,
   CallExpression,
@@ -72,6 +73,8 @@ import {
   setNextContainer,
   setReturnFlowNode,
   setSymbol,
+  callQuestionDotToken,
+  callTypeArguments,
 } from './ast.js';
 import {
   isAmbientModule,
@@ -795,7 +798,7 @@ class Binder extends NodeVisitor {
   }
 
   addDiagnostic(diagnostic: Diagnostic): void {
-    this.file.bindDiagnostics.push(diagnostic);
+    this.file.bindDiagnostics = appendToList(this.file.bindDiagnostics, diagnostic);
   }
 
   // Traversal
@@ -1885,8 +1888,8 @@ class Binder extends NodeVisitor {
       this.bindOptional((node as ElementAccessExpression).questionDotToken);
       this.bind((node as ElementAccessExpression).argumentExpression);
     } else if (node instanceof CallExpression) {
-      this.bindOptional((node as CallExpression).questionDotToken);
-      this.bindNodes((node as CallExpression).typeArguments);
+      this.bindOptional(callQuestionDotToken(node as CallExpression));
+      this.bindNodes(callTypeArguments(node as CallExpression));
       this.bindNodes((node as CallExpression).arguments);
     }
   }
@@ -1897,7 +1900,7 @@ class Binder extends NodeVisitor {
       // An IIFE's flow node includes the evaluation of its arguments.
       const callee = skipParentheses(node.expression);
       if (callee.kind === SyntaxKind.FunctionExpression || callee.kind === SyntaxKind.ArrowFunction) {
-        this.bindNodes(node.typeArguments);
+        this.bindNodes(callTypeArguments(node));
         this.bindNodes(node.arguments);
         this.bind(node.expression);
       } else {
@@ -1973,7 +1976,10 @@ class Binder extends NodeVisitor {
         if (starIndex >= 0 && text.indexOf('*', starIndex + 1) >= 0)
           this.errorOnFirstToken(name, Diagnostics.Pattern_0_can_have_at_most_one_Asterisk_character, [text]);
         else if (starIndex >= 0)
-          this.file.patternAmbientModules.push(new PatternAmbientModule(text, starIndex, symbol));
+          this.file.patternAmbientModules = appendToList(
+            this.file.patternAmbientModules,
+            new PatternAmbientModule(text, starIndex, symbol),
+          );
       }
       return;
     }

package/src/compiler/checker-calls.ts

@@ -25,6 +25,8 @@ import {
   getNodeId,
   getBody,
   getSymbol,
+  callQuestionDotToken,
+  callTypeArguments,
 } from './ast.js';
 import {
   canHaveDecorators,
@@ -238,7 +240,7 @@ export function checkCallExpression(c: Checker, node: Node, checkMode: CheckMode
     return getESSymbolLikeTypeForNode(c, walkUpParenthesizedExpressions(node.parent!));
   // An assertion call must name its target through explicitly typed declarations.
   if (
-    call.questionDotToken === undefined &&
+    callQuestionDotToken(call) === undefined &&
     node.parent!.kind === SyntaxKind.ExpressionStatement &&
     (returnType.flags & TypeFlags.Void) !== 0 &&
     getTypePredicateOfSignature(c, signature) !== undefined
@@ -368,7 +370,7 @@ function resolveCallExpression(c: Checker, node: CallExpression, checkMode: Chec
   const callSignatures = getSignaturesOfType(c, apparentType, SignatureKind.Call);
   const numConstructSignatures = getSignaturesOfType(c, apparentType, SignatureKind.Construct).length;
   if (isUntypedFunctionCall(c, funcType, apparentType, callSignatures.length, numConstructSignatures)) {
-    if (!isErrorType(c, funcType) && node.typeArguments !== undefined)
+    if (!isErrorType(c, funcType) && callTypeArguments(node) !== undefined)
       c.error(node, Diagnostics.Untyped_function_calls_may_not_accept_type_arguments);
     return resolveUntypedCall(c, node);
   }
@@ -382,7 +384,7 @@ function resolveCallExpression(c: Checker, node: CallExpression, checkMode: Chec
   // inferences can flow through function composition.
   if (
     (checkMode & CheckMode.SkipGenericFunctions) !== 0 &&
-    node.typeArguments === undefined &&
+    callTypeArguments(node) === undefined &&
     someGenericFunctionReturningFunction(c, callSignatures)
   ) {
     skippedGenericFunction(c, node, checkMode);

package/src/compiler/checker-contextual.ts

@@ -277,7 +277,7 @@ export function checkExpressionWithContextualType(
     checkMode | CheckMode.Contextual | (inferenceContext !== undefined ? CheckMode.Inferential : 0),
   );
   // Intra-expression inference sites only matter during this check.
-  if (inferenceContext !== undefined) inferenceContext.intraExpressionInferenceSites = [];
+  if (inferenceContext !== undefined) inferenceContext.intraExpressionInferenceSites = undefined;
   // Contextually typed literals keep their literal types rather than widening during inference.
   if (
     maybeTypeOfKind(t, TypeFlags.Literal) &&

package/src/compiler/checker-declaration-order.ts

@@ -37,7 +37,7 @@ import { getExportSymbolOfValueSymbolIfExported } from './checker-symbols.js';
 import { getBaseTypes, getDeclaredTypeOfSymbol } from './checker-declared-types.js';
 import { getPropertyOfType } from './checker-members.js';
 import { FunctionFlags, getFunctionFlags } from './checker-utilities.js';
-import { getDeclarations, type Symbol, SymbolFlags } from './symbol.js';
+import { declarationAt, declarationCount, type Symbol, SymbolFlags } from './symbol.js';
 
 /** Reports a block-scoped variable, class or enum resolved at `errorLocation` before its declaration. */
 export function checkResolvedBlockScopedVariable(c: Checker, resolved: Symbol, errorLocation: Node): void {
@@ -50,7 +50,8 @@ export function checkResolvedBlockScopedVariable(c: Checker, resolved: Symbol, e
   )
     return;
   let declaration: Node | undefined;
-  for (const d of getDeclarations(result)) {
+  for (let i = 0; i < declarationCount(result); i++) {
+    const d = declarationAt(result, i);
     if (isBlockOrCatchScoped(d) || isClassLike(d) || d.kind === SyntaxKind.EnumDeclaration) {
       declaration = d;
       break;

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

@@ -87,7 +87,7 @@ import { getIndexedAccessType, isGenericMappedType } from './checker-type-operat
 import { getSignatureInstantiation } from './checker-signatures.js';
 import { evaluateEnumMember, EvaluatedFlags, EvaluatedKind } from './checker-evaluator.js';
 import { checkTypeAssignableTo, isTypeIdenticalTo } from './relations.js';
-import { getDeclarations, type Symbol, SymbolFlags } from './symbol.js';
+import { declarationAt, declarationCount, getDeclarations, type Symbol, SymbolFlags } from './symbol.js';
 
 export { getParentOfSymbol };
 
@@ -877,9 +877,12 @@ export function getMinTypeArgumentCount(c: Checker, typeParameters: readonly Typ
 
 /** Whether a type parameter is declared with a default, without resolving it. */
 function hasTypeParameterDefault(t: Type): boolean {
-  if (t.symbol === undefined) return false;
-  for (const d of getDeclarations(t.symbol))
+  const symbol = t.symbol;
+  if (symbol === undefined) return false;
+  for (let i = 0; i < declarationCount(symbol); i++) {
+    const d = declarationAt(symbol, i);
     if (d.kind === SyntaxKind.TypeParameter && (d as TypeParameterDeclaration).defaultType !== undefined) return true;
+  }
   return false;
 }
 

package/src/compiler/checker-deprecation.ts

@@ -32,7 +32,7 @@ import { entityNameToString } from './checker-expressions.js';
 import { isErrorType } from './checker-type-factory.js';
 import { getPropertyOfType } from './checker-members.js';
 import { signatureToString } from './type-printer.js';
-import { declarationCount, getDeclarations, type Symbol, SymbolFlags } from './symbol.js';
+import { declarationAt, declarationCount, getDeclarations, type Symbol, SymbolFlags } from './symbol.js';
 
 /** Whether `declaration`, or the statement it belongs to, has a `@deprecated` JSDoc tag. */
 export function isDeprecatedDeclaration(declaration: Node): boolean {
@@ -56,25 +56,26 @@ function getJSDocDeprecatedTag(node: Node): Node | undefined {
  * members when all are.
  */
 export function isDeprecatedSymbol(c: Checker, symbol: Symbol): boolean {
-  const declarations = getDeclarations(symbol);
+  const count = declarationCount(symbol);
   const parentSymbol = getParentOfSymbol(c, symbol);
-  if (parentSymbol !== undefined && declarations.length > 1)
+  if (parentSymbol !== undefined && count > 1)
     return (parentSymbol.flags & SymbolFlags.Interface) !== 0
-      ? someDeprecatedDeclaration(declarations)
-      : everyDeprecatedDeclaration(declarations);
+      ? someDeprecatedDeclaration(symbol)
+      : everyDeprecatedDeclaration(symbol);
   return (
     (symbol.valueDeclaration !== undefined && isDeprecatedDeclaration(symbol.valueDeclaration)) ||
-    (declarations.length !== 0 && everyDeprecatedDeclaration(declarations))
+    (count !== 0 && everyDeprecatedDeclaration(symbol))
   );
 }
 
-function someDeprecatedDeclaration(declarations: readonly Node[]): boolean {
-  for (const d of declarations) if (isDeprecatedDeclaration(d)) return true;
+function someDeprecatedDeclaration(symbol: Symbol): boolean {
+  for (let i = 0; i < declarationCount(symbol); i++) if (isDeprecatedDeclaration(declarationAt(symbol, i))) return true;
   return false;
 }
 
-function everyDeprecatedDeclaration(declarations: readonly Node[]): boolean {
-  for (const d of declarations) if (!isDeprecatedDeclaration(d)) return false;
+function everyDeprecatedDeclaration(symbol: Symbol): boolean {
+  for (let i = 0; i < declarationCount(symbol); i++)
+    if (!isDeprecatedDeclaration(declarationAt(symbol, i))) return false;
   return true;
 }
 
@@ -330,7 +331,8 @@ export function checkDeprecatedTypeReference(c: Checker, node: Node, type: Type)
   if (isErrorType(c, type)) return;
   const symbol = c.resolvedSymbols.get(node.id);
   if (symbol === undefined) return;
-  for (const d of getDeclarations(symbol)) {
+  for (let i = 0; i < declarationCount(symbol); i++) {
+    const d = declarationAt(symbol, i);
     if (isTypeDeclaration(d) && isDeprecatedDeclaration(d)) {
       addDeprecatedSuggestion(c, getDeprecatedSuggestionNode(node), getDeclarations(symbol), symbol.name);
       return;

package/src/compiler/checker-destructuring.ts

@@ -115,7 +115,15 @@ import { TypeFacts, getNonNullableType, getTypeWithFacts, hasTypeFacts } from '.
 import { sliceTupleType } from './checker-signatures.js';
 import { getPropertyNameFromType, isTypeUsableAsPropertyName, maybeTypeOfKind } from './checker-utilities.js';
 import { checkPropertyAccessibility } from './checker-property-access.js';
-import { CheckFlags, copyDeclarations, getDeclarations, getSymbolId, type Symbol, SymbolFlags } from './symbol.js';
+import {
+  CheckFlags,
+  copyDeclarations,
+  declarationAt,
+  declarationCount,
+  getSymbolId,
+  type Symbol,
+  SymbolFlags,
+} from './symbol.js';
 
 function isBindingPatternNode(node: Node | undefined): boolean {
   return (
@@ -766,7 +774,8 @@ export function isSpreadableProperty(prop: Symbol): boolean {
     (prop.flags & (SymbolFlags.Method | SymbolFlags.GetAccessor | SymbolFlags.SetAccessor)) === 0;
   let hasPrivateName = false;
   let inClass = false;
-  for (const d of getDeclarations(prop)) {
+  for (let i = 0; i < declarationCount(prop); i++) {
+    const d = declarationAt(prop, i);
     if (isPrivateIdentifierClassElementDeclaration(d)) hasPrivateName = true;
     if (d.parent !== undefined && isClassLike(d.parent)) inClass = true;
   }