tsc-ts 0.0.5 → 0.0.7

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,
@@ -41,6 +42,7 @@ import {
   PrefixUnaryExpression,
   PropertyAccessExpression,
   QualifiedName,
+  ReferenceIdentifier,
   type SourceFile,
   SwitchStatement,
   TryStatement,
@@ -71,6 +73,8 @@ import {
   setNextContainer,
   setReturnFlowNode,
   setSymbol,
+  callQuestionDotToken,
+  callTypeArguments,
 } from './ast.js';
 import {
   isAmbientModule,
@@ -150,18 +154,21 @@ import { Diagnostic, type DiagnosticMessage, Diagnostics } from './diagnostics.j
 import { FlowFlags, FlowNode, FlowReduceLabel, FlowSwitchClause } from './flow.js';
 import { removeFileExtension } from './path.js';
 import { getIdentifierToken, tokenToString } from './scanner.js';
+import { SyntaxKind } from './syntax-kind.js';
 import {
-  InternalSymbolName,
-  Symbol,
-  SymbolFlags,
-  type SymbolTable,
   addDeclaration,
+  copyDeclarations,
+  declarationCount,
+  getDeclarations,
   getExports,
   getMembers,
   getSymbolId,
+  InternalSymbolName,
   internalSymbolNamePrefix,
+  Symbol,
+  SymbolFlags,
+  type SymbolTable,
 } from './symbol.js';
-import { SyntaxKind } from './syntax-kind.js';
 
 /** How a node scopes declarations and control flow. */
 export const enum ContainerFlags {
@@ -518,7 +525,7 @@ class Binder extends NodeVisitor {
       messageNeedsName = false;
     }
     let multipleDefaultExports = false;
-    if (symbol.declarations.length !== 0) {
+    if (declarationCount(symbol) !== 0) {
       // A default export (by modifier, or `export default` assignment) after another one.
       if (isDefaultExport || (node instanceof ExportAssignment && !(node as ExportAssignment).isExportEquals)) {
         message = Diagnostics.A_module_cannot_have_multiple_default_exports;
@@ -545,7 +552,7 @@ class Binder extends NodeVisitor {
         ]),
       );
     }
-    const declarations = symbol.declarations;
+    const declarations = getDeclarations(symbol);
     for (let index = 0; index < declarations.length; index++) {
       const declaration = declarations[index]!;
       const decl = getNameOfDeclaration(declaration) ?? declaration;
@@ -742,7 +749,7 @@ class Binder extends NodeVisitor {
   addDeclarationToSymbol(symbol: Symbol, node: Node, symbolFlags: SymbolFlags): void {
     symbol.flags |= symbolFlags;
     setSymbol(node, symbol);
-    if (symbol.declarations.indexOf(node) < 0) addDeclaration(symbol, node);
+    if (getDeclarations(symbol).indexOf(node) < 0) addDeclaration(symbol, node);
     // A const-enum-only namespace merged with a class, function or regular enum isn't one anymore.
     if (
       (symbol.flags & SymbolFlags.ConstEnumOnlyModule) !== 0 &&
@@ -791,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
@@ -805,7 +812,7 @@ class Binder extends NodeVisitor {
     // the container's locals; anonymous declarations like type literals go in no table.
     switch (node.kind) {
       case SyntaxKind.Identifier:
-        (node as Identifier).flowNode = this.currentFlowValue();
+        if (node instanceof ReferenceIdentifier) node.flowNode = this.currentFlowValue();
         this.checkContextualIdentifier(node as Identifier);
         break;
       case SyntaxKind.ThisKeyword:
@@ -1153,7 +1160,7 @@ class Binder extends NodeVisitor {
     symbol.valueDeclaration = this.file;
     if (name === 'module') {
       const exportsProperty = this.newSymbol(SymbolFlags.ModuleExports | SymbolFlags.Property, 'exports');
-      exportsProperty.declarations = symbol.declarations;
+      copyDeclarations(exportsProperty, symbol);
       exportsProperty.valueDeclaration = this.file;
       exportsProperty.parent = symbol;
       getMembers(symbol).set('exports', exportsProperty);
@@ -1881,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);
     }
   }
@@ -1893,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 {
@@ -1969,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;
     }
@@ -2096,7 +2106,7 @@ class Binder extends NodeVisitor {
     const exports = getExports(symbol);
     const existing = exports.get('prototype');
     if (existing !== undefined)
-      this.errorOnNode(existing.declarations[0]!, Diagnostics.Duplicate_identifier_0, ['prototype']);
+      this.errorOnNode(existing.declaration!, Diagnostics.Duplicate_identifier_0, ['prototype']);
     exports.set('prototype', prototypeSymbol);
     prototypeSymbol.parent = symbol;
   }

package/src/compiler/checker-calls.ts

@@ -25,6 +25,8 @@ import {
   getNodeId,
   getBody,
   getSymbol,
+  callQuestionDotToken,
+  callTypeArguments,
 } from './ast.js';
 import {
   canHaveDecorators,
@@ -46,7 +48,6 @@ import { Diagnostic, type DiagnosticMessage, Diagnostics, chainDiagnostic } from
 import { resolveInstanceofExpression } from './checker-operators.js';
 import { skipTrivia } from './scanner.js';
 import { SyntaxKind } from './syntax-kind.js';
-import { InternalSymbolName, type Symbol, SymbolFlags } from './symbol.js';
 import { TokenFlags } from './types.js';
 import { type Checker, createDiagnosticForNode } from './checker.js';
 import { checkSuperExpression } from './checker-super.js';
@@ -206,6 +207,7 @@ import {
   resolveJsxOpeningLikeElement,
 } from './checker-jsx.js';
 import { isCommonJSRequire, resolveExternalModuleTypeByLiteral } from './checker-javascript.js';
+import { declarationCount, getDeclarations, InternalSymbolName, type Symbol, SymbolFlags } from './symbol.js';
 
 /** The type of an optional chain's expression with the chain's `undefined` removed. */
 export function getOptionalExpressionType(c: Checker, exprType: Type, expression: Node): Type {
@@ -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);
@@ -1674,9 +1676,9 @@ function addImplementationSuccessElaboration(
   diagnostic: Diagnostic,
 ): void {
   const symbol = failed.declaration !== undefined ? getSymbol(failed.declaration) : undefined;
-  if (symbol === undefined || symbol.declarations.length <= 1) return;
+  if (symbol === undefined || declarationCount(symbol) <= 1) return;
   let implementation: Node | undefined;
-  for (const d of symbol.declarations) {
+  for (const d of getDeclarations(symbol)) {
     if (isFunctionLikeDeclarationKind(d.kind) && nodeIsPresent(getBody(d))) {
       implementation = d;
       break;

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

@@ -29,7 +29,6 @@ import { isFunctionLike } from './ast-utilities.js';
 import { type Checker, createDiagnosticForNode } from './checker.js';
 import { type Diagnostic, Diagnostics } from './diagnostics.js';
 import { ScriptTarget } from './options.js';
-import { type Symbol, SymbolFlags } from './symbol.js';
 import { getSymbolOfDeclaration } from './checker-symbols.js';
 import { getTypeOfSymbol } from './checker-symbol-types.js';
 import { isPropertyInitializedInStaticBlocks } from './checker-classes.js';
@@ -38,6 +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';
 
 /** 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,7 @@ export function checkResolvedBlockScopedVariable(c: Checker, resolved: Symbol, e
   )
     return;
   let declaration: Node | undefined;
-  for (const d of result.declarations) {
+  for (const d of getDeclarations(result)) {
     if (isBlockOrCatchScoped(d) || isClassLike(d) || d.kind === SyntaxKind.EnumDeclaration) {
       declaration = d;
       break;

package/src/compiler/checker-declarations.ts

@@ -62,7 +62,6 @@ import {
   isClassLike,
 } from './binder-utilities.js';
 import { Diagnostic, type DiagnosticMessage, Diagnostics } from './diagnostics.js';
-import { InternalSymbolName, type Symbol, SymbolFlags, getSymbolId } from './symbol.js';
 import { SyntaxKind } from './syntax-kind.js';
 import { type Checker, createDiagnosticForNode } from './checker.js';
 import { IntrinsicTypeKind, getLiteralTypeFromPropertyName, intrinsicTypeKind } from './checker-type-operators.js';
@@ -142,6 +141,14 @@ import { checkFunctionOrMethodSymbols } from './checker-overloads.js';
 import { checkJSDocFullSignature } from './checker-jsdoc.js';
 import { checkAliasSymbol } from './checker-modules.js';
 import { checkDecorators } from './checker-decorators.js';
+import {
+  declarationCount,
+  getDeclarations,
+  getSymbolId,
+  InternalSymbolName,
+  type Symbol,
+  SymbolFlags,
+} from './symbol.js';
 
 // ---- Variables and parameters
 
@@ -250,8 +257,8 @@ export function checkVariableLikeDeclaration(c: Checker, node: Node): void {
       checkTypeAssignableToAndOptionallyElaborate(c, initType, t, node, initializer);
       checkUsingDeclarationInitializer(c, node, initializer, initType);
     }
-    if (name !== undefined && symbol.declarations.length > 1) {
-      for (const d of symbol.declarations) {
+    if (name !== undefined && declarationCount(symbol) > 1) {
+      for (const d of getDeclarations(symbol)) {
         if (d !== node && isVariableLike(d) && !areDeclarationFlagsIdentical(d, node)) {
           reportNonIdenticalModifiers(c, name);
           break;
@@ -786,15 +793,15 @@ export function checkEnumDeclaration(c: Checker, node: Node): void {
   const links = c.symbolLinks(symbol);
   if (links.enumChecked) return;
   links.enumChecked = true;
-  if (symbol.declarations.length > 1) {
+  if (declarationCount(symbol) > 1) {
     const enumIsConst = isEnumConst(node);
-    for (const d of symbol.declarations)
+    for (const d of getDeclarations(symbol))
       if (d.kind === SyntaxKind.EnumDeclaration && isEnumConst(d) !== enumIsConst)
         c.error(getNameOfDeclaration(d), Diagnostics.Enum_declarations_must_all_be_const_or_non_const);
   }
   // Only one declaration of a merged enum may continue automatic numbering from zero.
   let seenEnumMissingInitialInitializer = false;
-  for (const d of symbol.declarations) {
+  for (const d of getDeclarations(symbol)) {
     if (d.kind !== SyntaxKind.EnumDeclaration) continue;
     const members = (d as EnumDeclaration).members.nodes;
     if (members.length === 0 || getInitializer(members[0]!) !== undefined) continue;
@@ -851,7 +858,7 @@ export function checkModuleDeclaration(c: Checker, node: Node): void {
         Diagnostics.Namespaces_are_not_allowed_in_global_script_files_when_0_is_enabled_If_this_file_is_not_intended_to_be_a_global_script_set_moduleDetection_to_force_or_add_an_empty_export_statement,
         c.compilerOptions.verbatimModuleSyntax === true ? 'verbatimModuleSyntax' : 'isolatedModules',
       );
-    if (symbol.declarations.length > 1) {
+    if (declarationCount(symbol) > 1) {
       const classOrFunction = getFirstNonAmbientClassOrFunctionDeclaration(symbol);
       if (classOrFunction !== undefined) {
         if (getSourceFileOfNode(node) !== getSourceFileOfNode(classOrFunction))
@@ -907,7 +914,7 @@ export function isInstantiatedModule(node: Node, preserveConstEnums: boolean): b
 }
 
 function getFirstNonAmbientClassOrFunctionDeclaration(symbol: Symbol): Node | undefined {
-  for (const d of symbol.declarations)
+  for (const d of getDeclarations(symbol))
     if (
       (d.kind === SyntaxKind.ClassDeclaration ||
         (d.kind === SyntaxKind.FunctionDeclaration && nodeIsPresent(getBody(d)))) &&
@@ -995,16 +1002,16 @@ export function checkExternalModuleExports(c: Checker, node: Node): void {
     if (id === InternalSymbolName.ExportStar || (symbol.flags & (SymbolFlags.Namespace | SymbolFlags.Enum)) !== 0)
       continue;
     let count = 0;
-    for (const d of symbol.declarations)
+    for (const d of getDeclarations(symbol))
       if (isNotOverload(d) && !isAccessorDeclaration(d) && d.kind !== SyntaxKind.InterfaceDeclaration) count++;
     // A type alias may merge with one value.
     if ((symbol.flags & SymbolFlags.TypeAlias) !== 0 && count <= 2) continue;
     if (count <= 1) continue;
     let allExportsProperties = true;
-    for (const d of symbol.declarations)
+    for (const d of getDeclarations(symbol))
       if (getAssignmentDeclarationKind(d) !== JSDeclarationKind.ExportsProperty) allExportsProperties = false;
     if (allExportsProperties) continue;
-    for (const d of symbol.declarations)
+    for (const d of getDeclarations(symbol))
       if (isNotOverload(d)) c.error(d, Diagnostics.Cannot_redeclare_exported_variable_0, id);
   }
 }
@@ -1063,7 +1070,7 @@ export function checkExportsOnMergedDeclarations(c: Checker, node: Node): void {
   let exported = DeclarationSpaces.None;
   let nonExported = DeclarationSpaces.None;
   let defaultExported = DeclarationSpaces.None;
-  for (const d of symbol.declarations) {
+  for (const d of getDeclarations(symbol)) {
     const spaces = getDeclarationSpaces(c, d);
     const flags = getEffectiveDeclarationFlags(d, ModifierFlags.Export | ModifierFlags.Default);
     if ((flags & ModifierFlags.Export) !== 0) {
@@ -1075,7 +1082,7 @@ export function checkExportsOnMergedDeclarations(c: Checker, node: Node): void {
   const commonForExportsAndLocals = exported & nonExported;
   const commonForDefaultAndNonDefault = defaultExported & nonDefaultExported;
   if (commonForExportsAndLocals === 0 && commonForDefaultAndNonDefault === 0) return;
-  for (const d of symbol.declarations) {
+  for (const d of getDeclarations(symbol)) {
     const spaces = getDeclarationSpaces(c, d);
     const name = getNameOfDeclaration(d);
     const text = declarationNameToString(getSourceFileOfNode(d), name);
@@ -1136,7 +1143,7 @@ function getAliasDeclarationSpaces(c: Checker, node: Node): DeclarationSpaces {
   const symbol = getSymbolOfDeclaration(c, node);
   if (symbol === undefined) return DeclarationSpaces.None;
   let result = DeclarationSpaces.None;
-  for (const d of resolveAlias(c, symbol).declarations) result |= getDeclarationSpaces(c, d);
+  for (const d of getDeclarations(resolveAlias(c, symbol))) result |= getDeclarationSpaces(c, d);
   return result;
 }
 

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

@@ -21,7 +21,6 @@ import {
 } from './ast.js';
 import { getSourceFileOfNode, isEnumConst, isObjectLiteralMethod } from './binder-utilities.js';
 import { 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 { elaborateNeverIntersection } from './checker-property-access.js';
@@ -88,6 +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';
 
 export { getParentOfSymbol };
 
@@ -153,7 +153,7 @@ export function getDeclaredTypeOfClassOrInterface(c: Checker, symbol: Symbol): I
 }
 
 function isThislessInterface(c: Checker, symbol: Symbol): boolean {
-  for (const declaration of symbol.declarations) {
+  for (const declaration of getDeclarations(symbol)) {
     if (declaration.kind !== SyntaxKind.InterfaceDeclaration) continue;
     if ((declaration.flags & NodeFlags.ContainsThis) !== 0) return false;
     for (const node of getExtendsHeritageClauseElements(declaration)) {
@@ -201,7 +201,7 @@ export function getExtendsHeritageClauseElement(node: Node): Node | undefined {
 }
 
 export function getClassLikeDeclarationOfSymbol(symbol: Symbol): Node | undefined {
-  for (const d of symbol.declarations)
+  for (const d of getDeclarations(symbol))
     if (d.kind === SyntaxKind.ClassDeclaration || d.kind === SyntaxKind.ClassExpression) return d;
   return undefined;
 }
@@ -210,7 +210,7 @@ function getOuterTypeParametersOfClassOrInterface(c: Checker, symbol: Symbol): T
   let declaration = symbol.valueDeclaration;
   if ((symbol.flags & (SymbolFlags.Class | SymbolFlags.Function)) === 0) {
     declaration = undefined;
-    for (const d of symbol.declarations) {
+    for (const d of getDeclarations(symbol)) {
       if (d.kind === SyntaxKind.InterfaceDeclaration) {
         declaration = d;
         break;
@@ -310,7 +310,7 @@ export function getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(c: Checker,
 }
 
 function appendLocalTypeParameters(c: Checker, types: Type[], symbol: Symbol): Type[] {
-  for (const node of symbol.declarations) {
+  for (const node of getDeclarations(symbol)) {
     if (
       node.kind === SyntaxKind.InterfaceDeclaration ||
       node.kind === SyntaxKind.ClassDeclaration ||
@@ -343,7 +343,7 @@ export function getDeclaredTypeOfTypeAlias(c: Checker, symbol: Symbol): Type {
   if (links.declaredType !== undefined) return links.declaredType;
   if (!pushTypeResolution(c, symbol, TypeSystemPropertyName.DeclaredType)) return c.errorType;
   let declaration: Node | undefined;
-  for (const d of symbol.declarations)
+  for (const d of getDeclarations(symbol))
     if (d.kind === SyntaxKind.TypeAliasDeclaration || d.kind === SyntaxKind.JSTypeAliasDeclaration) {
       declaration = d;
       break;
@@ -374,7 +374,7 @@ export function getDeclaredTypeOfEnum(c: Checker, symbol: Symbol): Type {
   const links = c.symbolLinks(symbol);
   if (links.declaredType !== undefined) return links.declaredType;
   const memberTypes: Type[] = [];
-  for (const declaration of symbol.declarations) {
+  for (const declaration of getDeclarations(symbol)) {
     if (declaration.kind !== SyntaxKind.EnumDeclaration) continue;
     for (const member of (declaration as EnumDeclaration).members.nodes) {
       if (!hasBindableName(member)) continue;
@@ -561,7 +561,7 @@ export function getBaseTypes(c: Checker, t: Type): Type[] {
       if ((t.symbol!.flags & SymbolFlags.Interface) !== 0) resolveBaseTypesOfInterface(c, t as InterfaceType);
     }
     if (!popTypeResolution(c))
-      for (const declaration of t.symbol!.declarations)
+      for (const declaration of getDeclarations(t.symbol!))
         if (declaration.kind === SyntaxKind.ClassDeclaration || declaration.kind === SyntaxKind.InterfaceDeclaration)
           reportCircularBaseType(c, declaration, t);
     // Circular defaults may leave members partially resolved; reset them.
@@ -659,7 +659,7 @@ function isInJS(node: Node): boolean {
 }
 
 function resolveBaseTypesOfInterface(c: Checker, t: InterfaceType): void {
-  for (const declaration of t.symbol!.declarations) {
+  for (const declaration of getDeclarations(t.symbol!)) {
     if (declaration.kind !== SyntaxKind.InterfaceDeclaration) continue;
     for (const node of getExtendsHeritageClauseElements(declaration)) {
       const baseType = getReducedType(c, getTypeFromTypeNode(c, node));
@@ -798,7 +798,7 @@ export function hasNonCircularBaseConstraint(c: Checker, t: Type): boolean {
 
 export function getConstraintDeclaration(t: Type): Node | undefined {
   if (t.symbol !== undefined)
-    for (const d of t.symbol.declarations)
+    for (const d of getDeclarations(t.symbol))
       if (d.kind === SyntaxKind.TypeParameter) {
         const constraint = (d as TypeParameterDeclaration).constraint;
         if (constraint !== undefined) return constraint;
@@ -850,7 +850,7 @@ export function getResolvedTypeParameterDefault(c: Checker, t: TypeParameter): T
       side.resolvedDefaultType = c.resolvingDefaultType;
       let defaultType: Type = c.noConstraintType;
       if (t.symbol !== undefined)
-        for (const d of t.symbol.declarations)
+        for (const d of getDeclarations(t.symbol))
           if (d.kind === SyntaxKind.TypeParameter) {
             const node = (d as TypeParameterDeclaration).defaultType;
             if (node !== undefined) {
@@ -878,7 +878,7 @@ 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 t.symbol.declarations)
+  for (const d of getDeclarations(t.symbol))
     if (d.kind === SyntaxKind.TypeParameter && (d as TypeParameterDeclaration).defaultType !== undefined) return true;
   return false;
 }

package/src/compiler/checker-decorators.ts

@@ -37,7 +37,6 @@ import {
   isAutoAccessorPropertyDeclaration,
 } from './binder-utilities.js';
 import { type DiagnosticMessage, Diagnostics } from './diagnostics.js';
-import { type Symbol, SymbolFlags, getSymbolId } from './symbol.js';
 import { SyntaxKind } from './syntax-kind.js';
 import { type Checker, createDiagnosticForNode } from './checker.js';
 import { ModuleKind, getEmitModuleKind, ScriptTarget, getUseDefineForClassFields } from './options.js';
@@ -89,6 +88,7 @@ import {
   getGlobalClassSetterDecoratorContextType,
   getGlobalTypedPropertyDescriptorType,
 } from './checker-globals.js';
+import { getDeclarations, getSymbolId, type Symbol, SymbolFlags } from './symbol.js';
 
 // ---- Checks
 
@@ -230,12 +230,12 @@ function checkMetadataTypeImport(c: Checker, typeNode: Node | undefined): void {
     (typeName.kind === SyntaxKind.Identifier ? SymbolFlags.Type : SymbolFlags.Namespace) | SymbolFlags.Alias;
   const rootSymbol = resolveName(c, rootName, getText(rootName), meaning, undefined, true, false);
   if (rootSymbol === undefined || (rootSymbol.flags & SymbolFlags.Alias) === 0 || symbolIsValue(c, rootSymbol)) return;
-  if (rootSymbol.declarations.some(isTypeOnlyImportOrExportDeclaration)) return;
+  if (getDeclarations(rootSymbol).some(isTypeOnlyImportOrExportDeclaration)) return;
   const diagnostic = c.error(
     typeName,
     Diagnostics.A_type_referenced_in_a_decorated_signature_must_be_imported_with_import_type_or_a_namespace_import_when_isolatedModules_and_emitDecoratorMetadata_are_enabled,
   );
-  const aliasDeclaration = rootSymbol.declarations.find(isAliasSymbolDeclaration);
+  const aliasDeclaration = getDeclarations(rootSymbol).find(isAliasSymbolDeclaration);
   if (aliasDeclaration !== undefined)
     diagnostic.addRelatedInfo(
       createDiagnosticForNode(aliasDeclaration, Diagnostics.X_0_was_imported_here, [getText(rootName)]),

package/src/compiler/checker-deprecation.ts

@@ -24,7 +24,6 @@ import { type Checker, createDiagnosticForNode } from './checker.js';
 import { type Signature, SignatureFlags, type Type } from './checker-types.js';
 import { type Diagnostic, Diagnostics } from './diagnostics.js';
 import { getJSDoc } from './parser.js';
-import { type Symbol, SymbolFlags } from './symbol.js';
 import { SyntaxKind } from './syntax-kind.js';
 import { getDeclarationOfAliasSymbol, getParentOfSymbol, resolveAlias } from './checker-symbols.js';
 import { getTargetOfAliasDeclaration } from './checker-modules.js';
@@ -33,6 +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';
 
 /** Whether `declaration`, or the statement it belongs to, has a `@deprecated` JSDoc tag. */
 export function isDeprecatedDeclaration(declaration: Node): boolean {
@@ -56,7 +56,7 @@ function getJSDocDeprecatedTag(node: Node): Node | undefined {
  * members when all are.
  */
 export function isDeprecatedSymbol(c: Checker, symbol: Symbol): boolean {
-  const declarations = symbol.declarations;
+  const declarations = getDeclarations(symbol);
   const parentSymbol = getParentOfSymbol(c, symbol);
   if (parentSymbol !== undefined && declarations.length > 1)
     return (parentSymbol.flags & SymbolFlags.Interface) !== 0
@@ -208,7 +208,7 @@ function isUncalledFunctionReference(c: Checker, node: Node, symbol: Symbol): bo
       node.kind === SyntaxKind.Identifier &&
       hasMatchingArgument(c, parent, node)
     );
-  for (const d of symbol.declarations) if (isFunctionLikeKind(d.kind) && !isDeprecatedDeclaration(d)) return false;
+  for (const d of getDeclarations(symbol)) if (isFunctionLikeKind(d.kind) && !isDeprecatedDeclaration(d)) return false;
   return true;
 }
 
@@ -263,9 +263,9 @@ export function resolveAliasWithDeprecationCheck(c: Checker, symbol: Symbol, loc
   while ((current.flags & SymbolFlags.Alias) !== 0) {
     const target = getImmediateAliasedSymbol(c, current);
     if (target === undefined || target === targetSymbol) break;
-    if (target.declarations.length !== 0) {
+    if (declarationCount(target) !== 0) {
       if (isDeprecatedSymbol(c, target)) {
-        addDeprecatedSuggestion(c, location, target.declarations, target.name);
+        addDeprecatedSuggestion(c, location, getDeclarations(target), target.name);
         break;
       }
       if (current === targetSymbol) break;
@@ -288,11 +288,11 @@ function getImmediateAliasedSymbol(c: Checker, symbol: Symbol): Symbol | undefin
 export function checkDeprecatedIdentifier(c: Checker, node: Node, localOrExportSymbol: Symbol): void {
   const targetSymbol = resolveAliasWithDeprecationCheck(c, localOrExportSymbol, node);
   if (
-    targetSymbol.declarations.length !== 0 &&
+    declarationCount(targetSymbol) !== 0 &&
     isDeprecatedSymbol(c, targetSymbol) &&
     isUncalledFunctionReference(c, node, targetSymbol)
   )
-    addDeprecatedSuggestion(c, node, targetSymbol.declarations, getText(node));
+    addDeprecatedSuggestion(c, node, getDeclarations(targetSymbol), getText(node));
 }
 
 /** Reports a property access to a deprecated property. */
@@ -301,9 +301,9 @@ export function checkDeprecatedProperty(c: Checker, node: Node, right: Node, pro
   if (
     isDeprecatedSymbol(c, targetPropSymbol) &&
     isUncalledFunctionReference(c, node, targetPropSymbol) &&
-    targetPropSymbol.declarations.length !== 0
+    declarationCount(targetPropSymbol) !== 0
   )
-    addDeprecatedSuggestion(c, right, targetPropSymbol.declarations, getText(right));
+    addDeprecatedSuggestion(c, right, getDeclarations(targetPropSymbol), getText(right));
 }
 
 /** Reports a property access resolved through a deprecated index signature. */
@@ -314,11 +314,7 @@ export function checkDeprecatedIndexSignature(c: Checker, right: Node, declarati
 
 /** Reports an element access or indexed access type selecting a deprecated property. */
 export function checkDeprecatedIndexedAccess(c: Checker, accessNode: Node, prop: Symbol, propName: string): void {
-  if (
-    prop.declarations.length === 0 ||
-    !isDeprecatedSymbol(c, prop) ||
-    !isUncalledFunctionReference(c, accessNode, prop)
-  )
+  if (declarationCount(prop) === 0 || !isDeprecatedSymbol(c, prop) || !isUncalledFunctionReference(c, accessNode, prop))
     return;
   const deprecatedNode =
     accessNode.kind === SyntaxKind.ElementAccessExpression
@@ -326,7 +322,7 @@ export function checkDeprecatedIndexedAccess(c: Checker, accessNode: Node, prop:
       : accessNode.kind === SyntaxKind.IndexedAccessType
         ? (accessNode as IndexedAccessTypeNode).indexType
         : accessNode;
-  addDeprecatedSuggestion(c, deprecatedNode, prop.declarations, propName);
+  addDeprecatedSuggestion(c, deprecatedNode, getDeclarations(prop), propName);
 }
 
 /** Reports a type reference or import type naming a deprecated type. */
@@ -334,9 +330,9 @@ 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 symbol.declarations) {
+  for (const d of getDeclarations(symbol)) {
     if (isTypeDeclaration(d) && isDeprecatedDeclaration(d)) {
-      addDeprecatedSuggestion(c, getDeprecatedSuggestionNode(node), symbol.declarations, symbol.name);
+      addDeprecatedSuggestion(c, getDeprecatedSuggestionNode(node), getDeclarations(symbol), symbol.name);
       return;
     }
   }
@@ -345,8 +341,8 @@ export function checkDeprecatedTypeReference(c: Checker, node: Node, type: Type)
 /** Reports an import specifier importing a deprecated declaration. */
 export function checkDeprecatedImportSpecifier(c: Checker, node: Node, symbol: Symbol): void {
   const targetSymbol = resolveAliasWithDeprecationCheck(c, symbol, node);
-  if (isDeprecatedSymbol(c, targetSymbol) && targetSymbol.declarations.length !== 0)
-    addDeprecatedSuggestion(c, node, targetSymbol.declarations, targetSymbol.name);
+  if (isDeprecatedSymbol(c, targetSymbol) && declarationCount(targetSymbol) !== 0)
+    addDeprecatedSuggestion(c, node, getDeclarations(targetSymbol), targetSymbol.name);
 }
 
 /** Reports a JSX attribute setting a deprecated property of the element's contextual props type. */
@@ -354,6 +350,6 @@ export function checkDeprecatedJsxAttribute(c: Checker, contextualType: Type, at
   const name = attribute.name;
   if (name.kind !== SyntaxKind.Identifier) return;
   const prop = getPropertyOfType(c, contextualType, getText(name));
-  if (prop !== undefined && prop.declarations.length !== 0 && isDeprecatedSymbol(c, prop))
-    addDeprecatedSuggestion(c, name, prop.declarations, getText(name));
+  if (prop !== undefined && declarationCount(prop) !== 0 && isDeprecatedSymbol(c, prop))
+    addDeprecatedSuggestion(c, name, getDeclarations(prop), getText(name));
 }

package/src/compiler/checker-destructuring.ts

@@ -33,7 +33,6 @@ import {
   isPrivateIdentifierClassElementDeclaration,
 } from './binder-utilities.js';
 import { Diagnostics } from './diagnostics.js';
-import { CheckFlags, SymbolFlags, type Symbol, getSymbolId } from './symbol.js';
 import { SyntaxKind } from './syntax-kind.js';
 import type { Checker } from './checker.js';
 import {
@@ -116,6 +115,7 @@ 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';
 
 function isBindingPatternNode(node: Node | undefined): boolean {
   return (
@@ -766,7 +766,7 @@ 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 prop.declarations) {
+  for (const d of getDeclarations(prop)) {
     if (isPrivateIdentifierClassElementDeclaration(d)) hasPrivateName = true;
     if (d.parent !== undefined && isClassLike(d.parent)) inClass = true;
   }
@@ -785,7 +785,7 @@ export function getSpreadSymbol(c: Checker, prop: Symbol, readonly: boolean): Sy
   );
   const id = getSymbolId(result);
   c.symbolTypes.set(id, isSetonlyAccessor ? c.undefinedType : getTypeOfSymbol(c, prop));
-  result.declarations = prop.declarations;
+  copyDeclarations(result, prop);
   c.symbolNameTypes.set(id, c.symbolNameTypes.get(getSymbolId(prop)));
   c.symbolSyntheticOrigins.set(id, prop);
   return result;