tsc-ts 0.0.5 → 0.0.6

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;

package/src/compiler/checker-elaboration.ts

@@ -16,7 +16,6 @@ import {
 import { getSourceFileOfNode } from './binder-utilities.js';
 import { type Diagnostic, type DiagnosticMessage, Diagnostics } from './diagnostics.js';
 import { SyntaxKind } from './syntax-kind.js';
-import { type Symbol, SymbolFlags } from './symbol.js';
 import { type Checker, createDiagnosticForNode } from './checker.js';
 import { AccessFlags, SignatureKind, type Type, TypeFlags } from './checker-types.js';
 import { getNumberLiteralType, getUnionType, isTupleType, typesOf } from './checker-type-factory.js';
@@ -49,6 +48,7 @@ import { FunctionFlags, getFunctionFlags } from './checker-utilities.js';
 import { typeToString } from './type-printer.js';
 import { CheckMode } from './checker-types.js';
 import { elaborateJsxComponents } from './checker-jsx.js';
+import { declarationCount, type Symbol, SymbolFlags } from './symbol.js';
 
 /** Checks that `source` relates to `target`, elaborating into `expr` when possible. */
 export function checkTypeRelatedToAndOptionallyElaborate(
@@ -381,13 +381,13 @@ export function elaborateElement(
   }
   if (
     !issuedElaboration &&
-    ((targetProp !== undefined && targetProp.declarations.length !== 0) ||
-      (target.symbol !== undefined && target.symbol.declarations.length !== 0))
+    ((targetProp !== undefined && declarationCount(targetProp) !== 0) ||
+      (target.symbol !== undefined && declarationCount(target.symbol) !== 0))
   ) {
     const targetNode =
-      targetProp !== undefined && targetProp.declarations.length !== 0
-        ? targetProp.declarations[0]!
-        : target.symbol!.declarations[0]!;
+      targetProp !== undefined && declarationCount(targetProp) !== 0
+        ? targetProp.declaration!
+        : target.symbol!.declaration!;
     if (propertyName === '' || (nameType.flags & TypeFlags.UniqueESSymbol) !== 0)
       propertyName = typeToString(c, nameType);
     if (!c.host.isSourceFileDefaultLibrary(getSourceFileOfNode(targetNode)))
@@ -456,10 +456,10 @@ function elaborateArrowFunction(
   checkTypeRelatedTo(c, sourceReturn, targetReturn, relation, returnExpression, undefined, diagnostics);
   if (diagnostics.length === 0) return false;
   const diagnostic = diagnostics[0]!;
-  if (target.symbol !== undefined && target.symbol.declarations.length !== 0)
+  if (target.symbol !== undefined && declarationCount(target.symbol) !== 0)
     diagnostic.addRelatedInfo(
       createDiagnosticForNode(
-        target.symbol.declarations[0]!,
+        target.symbol.declaration!,
         Diagnostics.The_expected_type_comes_from_the_return_type_of_this_signature,
         [],
       ),

package/src/compiler/checker-emit-resolver.ts

@@ -95,7 +95,6 @@ import { tryReuseExistingNode } from './node-builder-reuse.js';
 import type { CompilerOptions, ModuleKind } from './options.js';
 import type { EmitContext } from './printer/emit-context.js';
 import { isTypeIdenticalTo } from './relations.js';
-import { CheckFlags, type Symbol, SymbolFlags } from './symbol.js';
 import {
   beginDeclarationEmitVisibility,
   isDeclarationVisible,
@@ -116,6 +115,7 @@ import { SyntacticEmitResolver } from './transformers/emit-resolver.js';
 import type { Evaluation, ReferenceResolver } from './transformers/reference-resolver.js';
 import { TypeReferenceSerializationKind } from './transformers/type-serialization.js';
 import { TokenFlags } from './types.js';
+import { CheckFlags, declarationCount, getDeclarations, type Symbol, SymbolFlags } from './symbol.js';
 
 const declarationEmitInternalFlags = NodeBuilderInternalFlags.AllowUnresolvedNames;
 const aliasMeaning = SymbolFlags.Value | SymbolFlags.Type | SymbolFlags.Namespace | SymbolFlags.Alias;
@@ -218,7 +218,7 @@ export class CheckerDeclarationEmitResolver extends DeclarationEmitResolver {
     while (exportSymbol !== undefined && !visited.has(exportSymbol)) {
       visited.add(exportSymbol);
       let next: Symbol | undefined = undefined;
-      for (const declaration of exportSymbol.declarations) {
+      for (const declaration of getDeclarations(exportSymbol)) {
         markDeclarationVisible(c, declaration);
         if (
           declaration instanceof ImportEqualsDeclaration &&
@@ -265,7 +265,7 @@ export class CheckerDeclarationEmitResolver extends DeclarationEmitResolver {
     for (const s of getExportsOfModule(c, file.symbol).values()) {
       const merged = getMergedSymbol(c, s);
       if (merged === s) continue;
-      for (const d of merged.declarations) if (getSourceFileOfNode(d) === importTarget) return true;
+      for (const d of getDeclarations(merged)) if (getSourceFileOfNode(d) === importTarget) return true;
     }
     return false;
   }
@@ -621,8 +621,8 @@ export function getTypeReferenceSerializationKind(
   let isTypeOnly = false;
   if (typeName.kind === SyntaxKind.QualifiedName) {
     const root = resolveEntityName(c, getFirstIdentifier(typeName), SymbolFlags.Value, true, true, location);
-    if (root !== undefined && root.declarations.length > 0)
-      isTypeOnly = root.declarations.every(isTypeOnlyImportOrExportDeclaration);
+    if (root !== undefined && declarationCount(root) > 0)
+      isTypeOnly = getDeclarations(root).every(isTypeOnlyImportOrExportDeclaration);
   }
   const valueSymbol = resolveEntityName(c, typeName, SymbolFlags.Value, true, true, location);
   let resolvedValue = valueSymbol;

package/src/compiler/checker-grammar.ts

@@ -130,12 +130,12 @@ import { ModuleKind, ScriptTarget, getEmitModuleKind } from './options.js';
 import { fileExtensionIsOneOf, isExternalModuleNameRelative } from './path.js';
 import { SourceFileMetadata, getEmitModuleFormatOfFile, getImpliedNodeFormatForEmit } from './program-utilities.js';
 import { CharacterCodes } from './character-codes.js';
-import { Scanner, ScannerErrorReporter, computeLineOfPosition, skipTrivia, tokenToString } from './scanner.js';
-import { SymbolFlags } from './symbol.js';
+import { Scanner, ScannerErrorReporter, skipTrivia, tokenToString } from './scanner.js';
 import { typeToString } from './type-printer.js';
 import type { ScriptTarget as LanguageTarget } from './types.js';
 import { SyntaxKind } from './syntax-kind.js';
 import { findMismatchedAugmentsTag } from './checker-jsdoc.js';
+import { getDeclarations, SymbolFlags } from './symbol.js';
 
 /** Runs the grammar checks of every node of `file`. */
 export function checkGrammarSourceFile(c: Checker, file: SourceFile): void {
@@ -1266,7 +1266,7 @@ function getFirstAccessorOfPair(c: Checker, node: Node): Node {
   const symbol = getSymbolOfDeclaration(c, node);
   if (symbol === undefined) return node;
   const otherKind = node.kind === SyntaxKind.GetAccessor ? SyntaxKind.SetAccessor : SyntaxKind.GetAccessor;
-  for (const declaration of symbol.declarations)
+  for (const declaration of getDeclarations(symbol))
     if (declaration.kind === otherKind && declaration.pos < node.pos) return declaration;
   return node;
 }
@@ -1437,13 +1437,25 @@ function checkGrammarArrowFunction(g: GrammarChecker, node: Node): boolean {
   }
   const arrowToken = arrow.equalsGreaterThanToken;
   if (arrowToken === undefined) return false;
-  const lineStarts = g.file.lineStarts();
   return (
-    computeLineOfPosition(lineStarts, arrowToken.pos) !== computeLineOfPosition(lineStarts, arrowToken.end) &&
+    hasLineBreak(g.file.text, arrowToken.pos, arrowToken.end) &&
     grammarErrorOnNode(g, arrowToken, Diagnostics.Line_terminator_not_permitted_before_arrow)
   );
 }
 
+/**
+ * Whether a line starts in `(pos, end]`, so that `pos` and `end` are on different lines: after an
+ * LF, LS or PS, or a CR that no LF follows (`computeLineStarts`), without the file's line starts.
+ */
+function hasLineBreak(text: string, pos: number, end: number): boolean {
+  for (let i = pos; i < end; i++) {
+    const c = text.charCodeAt(i);
+    if (c === 0x0a || c === 0x2028 || c === 0x2029) return true;
+    if (c === 0x0d && text.charCodeAt(i + 1) !== 0x0a) return true;
+  }
+  return false;
+}
+
 function checkGrammarForGenerator(g: GrammarChecker, node: Node): boolean {
   const asteriskToken = getAsteriskToken(node);
   if (asteriskToken === undefined) return false;

package/src/compiler/checker-heritage.ts

@@ -31,7 +31,6 @@ import {
 } from './binder-utilities.js';
 import { type Diagnostic, type DiagnosticMessage, Diagnostics, chainDiagnostic } from './diagnostics.js';
 import { getUseDefineForClassFields } from './options.js';
-import { CheckFlags, InternalSymbolName, type Symbol, SymbolFlags } from './symbol.js';
 import { SyntaxKind } from './syntax-kind.js';
 import { type Checker, createDiagnosticForNode } from './checker.js';
 import {
@@ -115,6 +114,14 @@ import { Ternary } from './checker-types.js';
 import { symbolToString, typeToString } from './type-printer.js';
 import { checkFunctionOrConstructorSymbol } from './checker-overloads.js';
 import { isPropertyInitializedInConstructor } from './checker-classes.js';
+import {
+  CheckFlags,
+  declarationCount,
+  getDeclarations,
+  InternalSymbolName,
+  type Symbol,
+  SymbolFlags,
+} from './symbol.js';
 
 // ---- Classes
 
@@ -519,7 +526,7 @@ function checkPropertyOverwritesBase(
   derivedDeclarationFlags: ModifierFlags,
 ): void {
   let uninitialized: Node | undefined;
-  for (const d of derived.declarations) {
+  for (const d of getDeclarations(derived)) {
     if (d.kind === SyntaxKind.PropertyDeclaration && getInitializer(d) === undefined) {
       uninitialized = d;
       break;
@@ -532,7 +539,7 @@ function checkPropertyOverwritesBase(
     (derivedDeclarationFlags & ModifierFlags.Abstract) !== 0
   )
     return;
-  for (const d of derived.declarations) if ((d.flags & NodeFlags.Ambient) !== 0) return;
+  for (const d of getDeclarations(derived)) if ((d.flags & NodeFlags.Ambient) !== 0) return;
   const constructor = findConstructorDeclaration(getClassLikeDeclarationOfSymbol(t.symbol!)!);
   const propName = getName(uninitialized)!;
   const postfix = getPostfixToken(uninitialized);
@@ -618,10 +625,10 @@ function reportMissingAbstractMembers(c: Checker, node: Node | undefined, missin
 function arePropertiesAbstractOrInterface(base: Symbol, baseDeclarationFlags: ModifierFlags): boolean {
   // Synthetic (intersection) properties need any declaration to qualify; others need all.
   if ((base.checkFlags & CheckFlags.Synthetic) !== 0) {
-    for (const d of base.declarations) if (isPropertyAbstractOrInterface(d, baseDeclarationFlags)) return true;
+    for (const d of getDeclarations(base)) if (isPropertyAbstractOrInterface(d, baseDeclarationFlags)) return true;
     return false;
   }
-  for (const d of base.declarations) if (!isPropertyAbstractOrInterface(d, baseDeclarationFlags)) return false;
+  for (const d of getDeclarations(base)) if (!isPropertyAbstractOrInterface(d, baseDeclarationFlags)) return false;
   return true;
 }
 
@@ -733,14 +740,14 @@ function checkMemberForOverrideModifier(
   }
   if (
     baseProp === undefined ||
-    baseProp.declarations.length === 0 ||
+    declarationCount(baseProp) === 0 ||
     memberHasOverrideModifier ||
     c.compilerOptions.noImplicitOverride !== true ||
     (node.flags & NodeFlags.Ambient) !== 0
   )
     return;
   let baseHasAbstract = false;
-  for (const d of baseProp.declarations) {
+  for (const d of getDeclarations(baseProp)) {
     if (hasSyntacticModifier(d, ModifierFlags.Abstract)) {
       baseHasAbstract = true;
       break;
@@ -869,12 +876,12 @@ function checkInheritedPropertiesAreIdentical(c: Checker, t: InterfaceType, type
 
 /** Reports class and interface declarations of one symbol whose type parameters differ. */
 export function checkTypeParameterListsIdentical(c: Checker, symbol: Symbol): void {
-  if (symbol.declarations.length === 1) return;
+  if (declarationCount(symbol) === 1) return;
   const links = c.symbolLinks(symbol);
   if (links.typeParametersChecked) return;
   links.typeParametersChecked = true;
   const declarations: Node[] = [];
-  for (const d of symbol.declarations)
+  for (const d of getDeclarations(symbol))
     if (d.kind === SyntaxKind.ClassDeclaration || d.kind === SyntaxKind.InterfaceDeclaration) declarations.push(d);
   if (declarations.length <= 1) return;
   const t = getDeclaredTypeOfSymbol(c, symbol) as InterfaceType;
@@ -892,13 +899,13 @@ export function checkTypeParameterListsIdentical(c: Checker, symbol: Symbol): vo
 
 /** Reports the declarations of an `infer` type parameter declared more than once with different constraints. */
 export function checkInferTypeParameterDeclarations(c: Checker, symbol: Symbol): void {
-  if (symbol.declarations.length <= 1) return;
+  if (declarationCount(symbol) <= 1) return;
   const links = c.symbolLinks(symbol);
   if (links.typeParametersChecked) return;
   links.typeParametersChecked = true;
   const declarations: Node[] = [];
   const typeParameterLists: Node[][] = [];
-  for (const d of symbol.declarations) {
+  for (const d of getDeclarations(symbol)) {
     if (d.kind === SyntaxKind.TypeParameter) {
       declarations.push(d);
       typeParameterLists.push([d]);
@@ -1020,7 +1027,7 @@ function checkPropertyOrAccessor(
   kind: MemberKind,
   isStaticMember: boolean,
 ): void {
-  if (symbol.declarations.length <= 1) return;
+  if (declarationCount(symbol) <= 1) return;
   const state = names.get(symbol.name) ?? MemberKind.None;
   if (state === MemberKind.None) names.set(symbol.name, kind);
   // A second property, or a property combined with an accessor.
@@ -1203,11 +1210,11 @@ function checkTypeForDuplicateIndexSignatures(c: Checker, node: Node): void {
   const symbol = getSymbolOfDeclaration(c, node);
   if (symbol === undefined) return;
   const indexSymbol = getIndexSymbol(c, symbol);
-  if (indexSymbol === undefined || indexSymbol.declarations.length <= 1) return;
+  if (indexSymbol === undefined || declarationCount(indexSymbol) <= 1) return;
   // Late-bound index signatures may duplicate each other and explicit ones.
   const keyTypes: Type[] = [];
   const declarationsByKey: Node[][] = [];
-  for (const declaration of indexSymbol.declarations) {
+  for (const declaration of getDeclarations(indexSymbol)) {
     if (declaration.kind !== SyntaxKind.IndexSignature) continue;
     const parameters = getParameters(declaration)!.nodes;
     if (parameters.length !== 1) continue;

package/src/compiler/checker-inference.ts

@@ -13,7 +13,6 @@ import {
   type ConditionalTypeNode,
 } from './ast.js';
 import { hasSyntacticModifier } from './binder-utilities.js';
-import { CheckFlags, type Symbol, SymbolFlags, getSymbolId } from './symbol.js';
 import { SyntaxKind } from './syntax-kind.js';
 import type { Checker } from './checker.js';
 import {
@@ -194,6 +193,15 @@ import { getTypeFromTypeNode } from './checker-type-nodes.js';
 import { getMergedSymbol, getSymbolOfDeclaration } from './checker-symbols.js';
 import { parsePseudoBigInt } from './pseudo-bigint.js';
 import { getContextualTypeForInference } from './checker-contextual.js';
+import {
+  CheckFlags,
+  copyDeclarations,
+  declarationCount,
+  getDeclarations,
+  getSymbolId,
+  type Symbol,
+  SymbolFlags,
+} from './symbol.js';
 
 export const enum InferenceFlags {
   None = 0,
@@ -427,7 +435,7 @@ export function someInferenceHasCandidatesOrDefault(inferences: InferenceInfo[])
 function hasTypeParameterDefault(tp: Type): boolean {
   const symbol = tp.symbol;
   if (symbol === undefined) return false;
-  for (const d of symbol.declarations)
+  for (const d of getDeclarations(symbol))
     if (d.kind === SyntaxKind.TypeParameter && (d as TypeParameterDeclaration).defaultType !== undefined) return true;
   return false;
 }
@@ -1324,10 +1332,10 @@ function isTopLevelClassStaticSide(t: Type): boolean {
     (symbol.flags &
       (SymbolFlags.Function | SymbolFlags.Method | SymbolFlags.TypeLiteral | SymbolFlags.ObjectLiteral)) !==
       0 ||
-    symbol.declarations.length === 0
+    declarationCount(symbol) === 0
   )
     return false;
-  for (const d of symbol.declarations) {
+  for (const d of getDeclarations(symbol)) {
     if (
       d.kind !== SyntaxKind.ClassDeclaration &&
       d.kind !== SyntaxKind.InterfaceDeclaration &&
@@ -1370,7 +1378,7 @@ function createEmptyObjectTypeFromStringLiteral(c: Checker, t: Type): Type {
     const literalProp = c.newSymbol(SymbolFlags.Property, name);
     c.symbolTypes.set(getSymbolId(literalProp), c.anyType);
     if (u.symbol !== undefined) {
-      literalProp.declarations = u.symbol.declarations;
+      copyDeclarations(literalProp, u.symbol);
       literalProp.valueDeclaration = u.symbol.valueDeclaration;
     }
     members.set(name, literalProp);
@@ -1452,7 +1460,7 @@ function hasUnmatchedProperty(c: Checker, source: Type, target: Type, matchDiscr
   const t = getReducedApparentType(c, target);
   if (
     (t.flags & TypeFlags.UnionOrIntersection) === 0 ||
-    sideOf(c, t as UnionOrIntersectionType).resolvedProperties !== undefined
+    sideOf(c, t as UnionOrIntersectionType).membersOf?.resolvedProperties !== undefined
   )
     return getUnmatchedProperty(c, source, target, false, matchDiscriminantProperties) !== undefined;
   const containingType = t as UnionOrIntersectionType;
@@ -1495,7 +1503,7 @@ export function isConstTypeVariable(c: Checker, t: Type | undefined, depth: numb
   if (depth >= 5 || t === undefined) return false;
   if ((t.flags & TypeFlags.TypeParameter) !== 0) {
     if (t.symbol === undefined) return false;
-    for (const d of t.symbol.declarations) if (hasSyntacticModifier(d, ModifierFlags.Const)) return true;
+    for (const d of getDeclarations(t.symbol)) if (hasSyntacticModifier(d, ModifierFlags.Const)) return true;
     return false;
   }
   if ((t.flags & TypeFlags.UnionOrIntersection) !== 0) {
@@ -2031,7 +2039,7 @@ export function resolveReverseMappedTypeMembers(c: Checker, t: ReverseMappedType
       prop.name,
       checkFlags,
     );
-    inferredProp.declarations = prop.declarations;
+    copyDeclarations(inferredProp, prop);
     const links = c.symbolLinks(inferredProp);
     const id = inferredProp.id;
     c.symbolNameTypes.set(id, c.symbolNameTypes.get(getSymbolId(prop)));
@@ -2484,7 +2492,7 @@ export function getInferredTypeParameterConstraint(c: Checker, t: Type, omitType
   const inferences: Type[] = [];
   const symbol = t.symbol;
   if (symbol !== undefined)
-    for (const declaration of symbol.declarations) {
+    for (const declaration of getDeclarations(symbol)) {
       if (declaration.parent === undefined || declaration.parent.kind !== SyntaxKind.InferType) continue;
       let child: Node = declaration.parent;
       let parent = child.parent;

package/src/compiler/checker-javascript.ts

@@ -30,7 +30,6 @@ import {
   isStringOrNumericLiteralLike,
   isVariableDeclarationInitializedToRequire,
 } from './binder-utilities.js';
-import { type Symbol, SymbolFlags } from './symbol.js';
 import { SyntaxKind } from './syntax-kind.js';
 import type { Checker } from './checker.js';
 import { ObjectFlags, type Type, TypeFlags } from './checker-types.js';
@@ -67,6 +66,7 @@ import {
   getTypeOfPropertyInBaseClass,
   isAutoTypedProperty,
 } from './checker-classes.js';
+import { declarationCount, getDeclarations, type Symbol, SymbolFlags } from './symbol.js';
 
 /** How the `this.x` assignments declaring a property are typed. */
 const enum ThisAssignmentKind {
@@ -99,7 +99,7 @@ export function getWidenedTypeForAssignmentDeclaration(c: Checker, symbol: Symbo
   else if (kind === ThisAssignmentKind.Method) t = getTypeOfPropertyInBaseClass(c, symbol);
   if (t === undefined) {
     const types: Type[] = [];
-    const declarations = symbol.declarations;
+    const declarations = getDeclarations(symbol);
     for (let i = 0; i < declarations.length; i++) {
       const declaration = declarations[i]!;
       const declaredType = declaration instanceof BinaryExpression ? (declaration as BinaryExpression).type : undefined;
@@ -234,7 +234,7 @@ function getThisAssignmentKind(c: Checker, symbol: Symbol): ThisAssignmentKind {
   if (links.thisAssignmentKind !== 0) return (links.thisAssignmentKind - 1) as ThisAssignmentKind;
   let allThis = true;
   let typeAnnotation: Node | undefined;
-  for (const declaration of symbol.declarations) {
+  for (const declaration of getDeclarations(symbol)) {
     if (!(declaration instanceof BinaryExpression)) {
       allThis = false;
       break;
@@ -276,7 +276,7 @@ export function isConstructorDeclaredThisProperty(c: Checker, symbol: Symbol): b
 }
 
 function getDeclaringConstructor(symbol: Symbol): Node | undefined {
-  for (const declaration of symbol.declarations) {
+  for (const declaration of getDeclarations(symbol)) {
     const container = getThisContainer(declaration, false, false);
     if (container.kind === SyntaxKind.Constructor) return container;
   }
@@ -498,5 +498,5 @@ export function isUndefinedAssignmentToCommonJSExport(c: Checker, left: Node, ri
   if (assignment.symbol === undefined) return false;
   if (getAssignmentDeclarationKind(assignment) !== JSDeclarationKind.ExportsProperty) return false;
   const symbol = c.resolvedSymbols.get(left.id);
-  return symbol !== undefined && symbol.declarations.length > 1 && (rightType.flags & TypeFlags.Undefined) !== 0;
+  return symbol !== undefined && declarationCount(symbol) > 1 && (rightType.flags & TypeFlags.Undefined) !== 0;
 }

package/src/compiler/checker-jsx.ts

@@ -30,7 +30,6 @@ import { Diagnostic, type DiagnosticMessage, Diagnostics, chainDiagnostic } from
 import { JsxEmit } from './options.js';
 import { parseIsolatedEntityName } from './parser.js';
 import { skipTrivia } from './scanner.js';
-import { InternalSymbolName, type Symbol, SymbolFlags, type SymbolTable, getSymbolId } from './symbol.js';
 import { SyntaxKind } from './syntax-kind.js';
 import { type Checker, createDiagnosticForNode } from './checker.js';
 import {
@@ -162,6 +161,15 @@ import { getIndexedAccessType } from './checker-type-operators.js';
 import { filterType, isTupleType } from './checker-type-factory.js';
 import { createTypeFromGenericGlobalType } from './checker-type-factory.js';
 import { isTypeAssignableTo } from './relations.js';
+import {
+  copyDeclarations,
+  declarationCount,
+  getSymbolId,
+  InternalSymbolName,
+  type Symbol,
+  SymbolFlags,
+  type SymbolTable,
+} from './symbol.js';
 
 const enum JsxFlags {
   None = 0,
@@ -549,12 +557,8 @@ function getNameFromJsxElementAttributesContainer(c: Checker, containerName: str
       const props = getPropertiesOfType(c, getDeclaredTypeOfSymbol(c, sym));
       if (props.length === 0) return '';
       if (props.length === 1) return props[0]!.name;
-      if (sym.declarations.length !== 0)
-        c.error(
-          sym.declarations[0]!,
-          Diagnostics.The_global_type_JSX_0_may_not_have_more_than_one_property,
-          containerName,
-        );
+      if (declarationCount(sym) !== 0)
+        c.error(sym.declaration!, Diagnostics.The_global_type_JSX_0_may_not_have_more_than_one_property, containerName);
     }
   }
   return InternalSymbolName.Missing;
@@ -953,7 +957,7 @@ export function createJsxAttributesTypeFromAttributesProperty(
         const exprType = checkJsxAttribute(c, attributeDecl, checkMode);
         objectFlags |= exprType.objectFlags & ObjectFlags.PropagatingFlags;
         const attributeSymbol = c.newSymbol(SymbolFlags.Property | member.flags, member.name);
-        attributeSymbol.declarations = member.declarations;
+        copyDeclarations(attributeSymbol, member);
         attributeSymbol.parent = member.parent;
         if (member.valueDeclaration !== undefined) attributeSymbol.valueDeclaration = member.valueDeclaration;
         const id = getSymbolId(attributeSymbol);

package/src/compiler/checker-literals.ts

@@ -1,6 +1,6 @@
 // Object literal types: freshness and regular forms.
 import type { Checker } from './checker.js';
-import { CheckFlags, type Symbol, getSymbolId } from './symbol.js';
+import { CheckFlags, copyDeclarations, getSymbolId, type Symbol } from './symbol.js';
 import { CachedTypeKind, cachedTypeKey, ObjectFlags, type Type, TypeFlags } from './checker-types.js';
 import { createAnonymousType } from './checker-type-factory.js';
 import { getPropertiesOfObjectType, resolveStructuredTypeMembers } from './checker-members.js';
@@ -41,7 +41,7 @@ export function getRegularTypeOfObjectLiteral(c: Checker, t: Type): Type {
 
 function createSymbolWithTypeLocal(c: Checker, source: Symbol, t: Type): Symbol {
   const symbol = c.newSymbolWithCheckFlags(source.flags, source.name, source.checkFlags & CheckFlags.Readonly);
-  symbol.declarations = source.declarations;
+  copyDeclarations(symbol, source);
   symbol.parent = source.parent;
   symbol.valueDeclaration = source.valueDeclaration;
   const id = getSymbolId(symbol);