tsc-ts 0.0.5 → 0.0.6

package/dist/api/compiler/checker-deprecation.js

@@ -12,6 +12,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 } from './symbol.js';
 /** Whether `declaration`, or the statement it belongs to, has a `@deprecated` JSDoc tag. */
 export function isDeprecatedDeclaration(declaration) {
     if ((getCombinedNodeFlags(declaration) & 67108864 /* NodeFlags.PossiblyContainsDeprecatedTag */) === 0)
@@ -37,7 +38,7 @@ function getJSDocDeprecatedTag(node) {
  * members when all are.
  */
 export function isDeprecatedSymbol(c, symbol) {
-    const declarations = symbol.declarations;
+    const declarations = getDeclarations(symbol);
     const parentSymbol = getParentOfSymbol(c, symbol);
     if (parentSymbol !== undefined && declarations.length > 1)
         return (parentSymbol.flags & 64 /* SymbolFlags.Interface */) !== 0
@@ -177,7 +178,7 @@ function isUncalledFunctionReference(c, node, symbol) {
         return ((parent.kind === 214 /* SyntaxKind.CallExpression */ || parent.kind === 215 /* SyntaxKind.NewExpression */) &&
             node.kind === 79 /* SyntaxKind.Identifier */ &&
             hasMatchingArgument(c, parent, node));
-    for (const d of symbol.declarations)
+    for (const d of getDeclarations(symbol))
         if (isFunctionLikeKind(d.kind) && !isDeprecatedDeclaration(d))
             return false;
     return true;
@@ -231,9 +232,9 @@ export function resolveAliasWithDeprecationCheck(c, symbol, location) {
         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)
@@ -253,18 +254,18 @@ function getImmediateAliasedSymbol(c, symbol) {
 /** Resolves the alias an identifier refers to and reports a deprecated target. */
 export function checkDeprecatedIdentifier(c, node, localOrExportSymbol) {
     const targetSymbol = resolveAliasWithDeprecationCheck(c, localOrExportSymbol, node);
-    if (targetSymbol.declarations.length !== 0 &&
+    if (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. */
 export function checkDeprecatedProperty(c, node, right, prop) {
     const targetPropSymbol = resolveAliasWithDeprecationCheck(c, prop, right);
     if (isDeprecatedSymbol(c, targetPropSymbol) &&
         isUncalledFunctionReference(c, node, targetPropSymbol) &&
-        targetPropSymbol.declarations.length !== 0)
-        addDeprecatedSuggestion(c, right, targetPropSymbol.declarations, getText(right));
+        declarationCount(targetPropSymbol) !== 0)
+        addDeprecatedSuggestion(c, right, getDeclarations(targetPropSymbol), getText(right));
 }
 /** Reports a property access resolved through a deprecated index signature. */
 export function checkDeprecatedIndexSignature(c, right, declaration) {
@@ -273,16 +274,14 @@ export function checkDeprecatedIndexSignature(c, right, declaration) {
 }
 /** Reports an element access or indexed access type selecting a deprecated property. */
 export function checkDeprecatedIndexedAccess(c, accessNode, prop, propName) {
-    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 === 213 /* SyntaxKind.ElementAccessExpression */
         ? accessNode.argumentExpression
         : accessNode.kind === 200 /* SyntaxKind.IndexedAccessType */
             ? accessNode.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. */
 export function checkDeprecatedTypeReference(c, node, type) {
@@ -291,9 +290,9 @@ export function checkDeprecatedTypeReference(c, node, type) {
     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;
         }
     }
@@ -301,8 +300,8 @@ export function checkDeprecatedTypeReference(c, node, type) {
 /** Reports an import specifier importing a deprecated declaration. */
 export function checkDeprecatedImportSpecifier(c, node, symbol) {
     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. */
 export function checkDeprecatedJsxAttribute(c, contextualType, attribute) {
@@ -310,6 +309,6 @@ export function checkDeprecatedJsxAttribute(c, contextualType, attribute) {
     if (name.kind !== 79 /* 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/dist/api/compiler/checker-destructuring.d.ts

@@ -1,7 +1,7 @@
 import { type BindingElement, type Node } from './ast.js';
-import { type Symbol } from './symbol.js';
 import type { Checker } from './checker.js';
 import { CheckMode, type Type } from './checker-types.js';
+import { type Symbol } from './symbol.js';
 /** The type of a binding element, from the type of the declaration it destructures. */
 export declare function getTypeForBindingElement(c: Checker, declaration: Node): Type | undefined;
 export declare function getTypeForBindingElementParent(c: Checker, node: Node, checkMode: CheckMode): Type | undefined;

package/dist/api/compiler/checker-destructuring.js

@@ -6,7 +6,6 @@ import { getElements, getInitializer, getName, getProperties, getSymbol, getType
 import { isLeftHandSideExpression } from './ast-utilities.js';
 import { getFlowTypeOfReference, getDestructuringPropertyName, getTypeOfInitializer } from './checker-narrowing.js';
 import { getRootDeclaration, isClassLike, isPartOfParameterDeclaration, isPrivateIdentifierClassElementDeclaration, } from './binder-utilities.js';
-import { getSymbolId } from './symbol.js';
 import { TupleElementInfo, } from './checker-types.js';
 import { cloneTypeReference, createAnonymousType, createArrayType, createTupleTypeEx, getElementTypes, getTypeReferenceArity, tupleTargetOf, everyType, filterType, getNumberLiteralType, getUnionType, getUnionTypeEx, isTupleType, mapType, newIndexInfo, someType, typesOf, } from './checker-type-factory.js';
 import { getIndexedAccessTypeEx, getIndexedAccessTypeOrUndefinedEx, getLiteralTypeFromProperty, getLiteralTypeFromPropertyName, isGenericIndexType, isGenericObjectType, } from './checker-type-operators.js';
@@ -23,6 +22,7 @@ import { getNonNullableType, getTypeWithFacts, hasTypeFacts } from './checker-fl
 import { sliceTupleType } from './checker-signatures.js';
 import { getPropertyNameFromType, isTypeUsableAsPropertyName, maybeTypeOfKind } from './checker-utilities.js';
 import { checkPropertyAccessibility } from './checker-property-access.js';
+import { copyDeclarations, getDeclarations, getSymbolId } from './symbol.js';
 function isBindingPatternNode(node) {
     return (node !== undefined &&
         (node.kind === 207 /* SyntaxKind.ObjectBindingPattern */ || node.kind === 208 /* SyntaxKind.ArrayBindingPattern */));
@@ -548,7 +548,7 @@ export function isSpreadableProperty(prop) {
     const notMethodOrAccessor = (prop.flags & (8192 /* SymbolFlags.Method */ | 32768 /* SymbolFlags.GetAccessor */ | 65536 /* 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))
@@ -564,7 +564,7 @@ export function getSpreadSymbol(c, prop, readonly) {
     const result = c.newSymbolWithCheckFlags(4 /* SymbolFlags.Property */ | (prop.flags & 16777216 /* SymbolFlags.Optional */), prop.name, (prop.checkFlags & 4096 /* CheckFlags.Late */) | (readonly ? 8 /* CheckFlags.Readonly */ : 0));
     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/dist/api/compiler/checker-elaboration.js

@@ -18,6 +18,7 @@ import { createPromiseType } from './checker-iteration.js';
 import { getFunctionFlags } from './checker-utilities.js';
 import { typeToString } from './type-printer.js';
 import { elaborateJsxComponents } from './checker-jsx.js';
+import { declarationCount } from './symbol.js';
 /** Checks that `source` relates to `target`, elaborating into `expr` when possible. */
 export function checkTypeRelatedToAndOptionallyElaborate(c, source, target, relation, errorNode, expr, headMessage, diagnosticOutput) {
     if (isTypeRelatedTo(c, source, target, relation))
@@ -221,11 +222,11 @@ export function elaborateElement(c, source, target, relation, prop, next, nameTy
         }
     }
     if (!issuedElaboration &&
-        ((targetProp !== undefined && targetProp.declarations.length !== 0) ||
-            (target.symbol !== undefined && target.symbol.declarations.length !== 0))) {
-        const targetNode = targetProp !== undefined && targetProp.declarations.length !== 0
-            ? targetProp.declarations[0]
-            : target.symbol.declarations[0];
+        ((targetProp !== undefined && declarationCount(targetProp) !== 0) ||
+            (target.symbol !== undefined && declarationCount(target.symbol) !== 0))) {
+        const targetNode = targetProp !== undefined && declarationCount(targetProp) !== 0
+            ? targetProp.declaration
+            : target.symbol.declaration;
         if (propertyName === '' || (nameType.flags & 16384 /* TypeFlags.UniqueESSymbol */) !== 0)
             propertyName = typeToString(c, nameType);
         if (!c.host.isSourceFileDefaultLibrary(getSourceFileOfNode(targetNode)))
@@ -279,8 +280,8 @@ function elaborateArrowFunction(c, node, source, target, relation, diagnosticOut
     if (diagnostics.length === 0)
         return false;
     const diagnostic = diagnostics[0];
-    if (target.symbol !== undefined && target.symbol.declarations.length !== 0)
-        diagnostic.addRelatedInfo(createDiagnosticForNode(target.symbol.declarations[0], 1517 /* Diagnostics.The_expected_type_comes_from_the_return_type_of_this_signature */, []));
+    if (target.symbol !== undefined && declarationCount(target.symbol) !== 0)
+        diagnostic.addRelatedInfo(createDiagnosticForNode(target.symbol.declaration, 1517 /* Diagnostics.The_expected_type_comes_from_the_return_type_of_this_signature */, []));
     if ((getFunctionFlags(node) & 2 /* FunctionFlags.Async */) === 0 &&
         getTypeOfPropertyOfType(c, sourceReturn, 'then') === undefined &&
         checkTypeRelatedTo(c, createPromiseType(c, sourceReturn), targetReturn, relation, undefined, undefined, undefined))

package/dist/api/compiler/checker-emit-resolver.d.ts

@@ -2,12 +2,12 @@ import { type EntityName, type FileReference, type Identifier, type ImportDeclar
 import type { Checker } from './checker.js';
 import type { CompilerOptions, ModuleKind } from './options.js';
 import type { EmitContext } from './printer/emit-context.js';
-import { type Symbol, SymbolFlags } from './symbol.js';
 import { DeclarationEmitResolver, NodeBuilderFlags, type SymbolAccessibilityResult, type SymbolTracker } from './transformers/declarations-resolver.js';
 import type { SyntacticDeclarationEmitResolver } from './transformers/declarations-syntactic.js';
 import { SyntacticEmitResolver } from './transformers/emit-resolver.js';
 import type { Evaluation, ReferenceResolver } from './transformers/reference-resolver.js';
 import { TypeReferenceSerializationKind } from './transformers/type-serialization.js';
+import { type Symbol, SymbolFlags } from './symbol.js';
 export declare class CheckerDeclarationEmitResolver extends DeclarationEmitResolver {
     readonly checker: Checker;
     /** Answers the queries that don't need types. */

package/dist/api/compiler/checker-emit-resolver.js

@@ -25,6 +25,7 @@ import { isTypeIdenticalTo } from './relations.js';
 import { beginDeclarationEmitVisibility, isDeclarationVisible, isSymbolAccessible, markDeclarationVisible, } from './symbol-accessibility.js';
 import { DeclarationEmitResolver, } from './transformers/declarations-resolver.js';
 import { SyntacticEmitResolver } from './transformers/emit-resolver.js';
+import { declarationCount, getDeclarations } from './symbol.js';
 const declarationEmitInternalFlags = 8 /* NodeBuilderInternalFlags.AllowUnresolvedNames */;
 const aliasMeaning = 111551 /* SymbolFlags.Value */ | 788968 /* SymbolFlags.Type */ | 1920 /* SymbolFlags.Namespace */ | 2097152 /* SymbolFlags.Alias */;
 export class CheckerDeclarationEmitResolver extends DeclarationEmitResolver {
@@ -105,7 +106,7 @@ export class CheckerDeclarationEmitResolver extends DeclarationEmitResolver {
         while (exportSymbol !== undefined && !visited.has(exportSymbol)) {
             visited.add(exportSymbol);
             let next = undefined;
-            for (const declaration of exportSymbol.declarations) {
+            for (const declaration of getDeclarations(exportSymbol)) {
                 markDeclarationVisible(c, declaration);
                 if (declaration instanceof ImportEqualsDeclaration &&
                     declaration.moduleReference.kind !== 284 /* SyntaxKind.ExternalModuleReference */) {
@@ -144,7 +145,7 @@ export class CheckerDeclarationEmitResolver extends DeclarationEmitResolver {
             const merged = getMergedSymbol(c, s);
             if (merged === s)
                 continue;
-            for (const d of merged.declarations)
+            for (const d of getDeclarations(merged))
                 if (getSourceFileOfNode(d) === importTarget)
                     return true;
         }
@@ -430,8 +431,8 @@ export function getTypeReferenceSerializationKind(c, typeName, location) {
     let isTypeOnly = false;
     if (typeName.kind === 167 /* SyntaxKind.QualifiedName */) {
         const root = resolveEntityName(c, getFirstIdentifier(typeName), 111551 /* 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, 111551 /* SymbolFlags.Value */, true, true, location);
     let resolvedValue = valueSymbol;

package/dist/api/compiler/checker-grammar.js

@@ -20,9 +20,10 @@ import { Diagnostic, messageCategory } from './diagnostics.js';
 import { ModuleKind, ScriptTarget, getEmitModuleKind } from './options.js';
 import { fileExtensionIsOneOf, isExternalModuleNameRelative } from './path.js';
 import { SourceFileMetadata, getEmitModuleFormatOfFile, getImpliedNodeFormatForEmit } from './program-utilities.js';
-import { Scanner, ScannerErrorReporter, computeLineOfPosition, skipTrivia, tokenToString } from './scanner.js';
+import { Scanner, ScannerErrorReporter, skipTrivia, tokenToString } from './scanner.js';
 import { typeToString } from './type-printer.js';
 import { findMismatchedAugmentsTag } from './checker-jsdoc.js';
+import { getDeclarations } from './symbol.js';
 /** Runs the grammar checks of every node of `file`. */
 export function checkGrammarSourceFile(c, file) {
     const g = new GrammarChecker(c, file);
@@ -821,7 +822,7 @@ function getFirstAccessorOfPair(c, node) {
     if (symbol === undefined)
         return node;
     const otherKind = node.kind === 178 /* SyntaxKind.GetAccessor */ ? 179 /* SyntaxKind.SetAccessor */ : 178 /* 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;
@@ -969,10 +970,23 @@ function checkGrammarArrowFunction(g, node) {
     const arrowToken = arrow.equalsGreaterThanToken;
     if (arrowToken === undefined)
         return false;
-    const lineStarts = g.file.lineStarts();
-    return (computeLineOfPosition(lineStarts, arrowToken.pos) !== computeLineOfPosition(lineStarts, arrowToken.end) &&
+    return (hasLineBreak(g.file.text, arrowToken.pos, arrowToken.end) &&
         grammarErrorOnNode(g, arrowToken, 156 /* 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, pos, end) {
+    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, node) {
     const asteriskToken = getAsteriskToken(node);
     if (asteriskToken === undefined)

package/dist/api/compiler/checker-heritage.d.ts

@@ -1,7 +1,7 @@
 import { type Node } from './ast.js';
-import { type Symbol } from './symbol.js';
 import { type Checker } from './checker.js';
 import { type Type } from './checker-types.js';
+import { type Symbol } from './symbol.js';
 /** Checks a class's merged declarations, members, base class, implemented types and index signatures. */
 export declare function checkClassHeritage(c: Checker, node: Node): void;
 /**

package/dist/api/compiler/checker-heritage.js

@@ -24,6 +24,7 @@ import { checkTypeAssignableTo, checkTypeRelatedTo, compareProperties, isTypeAss
 import { symbolToString, typeToString } from './type-printer.js';
 import { checkFunctionOrConstructorSymbol } from './checker-overloads.js';
 import { isPropertyInitializedInConstructor } from './checker-classes.js';
+import { declarationCount, getDeclarations, } from './symbol.js';
 // ---- Classes
 /** Checks a class's merged declarations, members, base class, implemented types and index signatures. */
 export function checkClassHeritage(c, node) {
@@ -349,7 +350,7 @@ function isImplementedByOtherBaseType(c, t, baseType, base) {
 /** With `useDefineForClassFields`, a redeclared property without an initializer resets the base value. */
 function checkPropertyOverwritesBase(c, t, baseType, base, derived, baseDeclarationFlags, derivedDeclarationFlags) {
     let uninitialized;
-    for (const d of derived.declarations) {
+    for (const d of getDeclarations(derived)) {
         if (d.kind === 173 /* SyntaxKind.PropertyDeclaration */ && getInitializer(d) === undefined) {
             uninitialized = d;
             break;
@@ -360,7 +361,7 @@ function checkPropertyOverwritesBase(c, t, baseType, base, derived, baseDeclarat
         (baseDeclarationFlags & 64 /* ModifierFlags.Abstract */) !== 0 ||
         (derivedDeclarationFlags & 64 /* ModifierFlags.Abstract */) !== 0)
         return;
-    for (const d of derived.declarations)
+    for (const d of getDeclarations(derived))
         if ((d.flags & 8388608 /* NodeFlags.Ambient */) !== 0)
             return;
     const constructor = findConstructorDeclaration(getClassLikeDeclarationOfSymbol(t.symbol));
@@ -404,12 +405,12 @@ function reportMissingAbstractMembers(c, node, missing) {
 function arePropertiesAbstractOrInterface(base, baseDeclarationFlags) {
     // Synthetic (intersection) properties need any declaration to qualify; others need all.
     if ((base.checkFlags & 6 /* CheckFlags.Synthetic */) !== 0) {
-        for (const d of base.declarations)
+        for (const d of getDeclarations(base))
             if (isPropertyAbstractOrInterface(d, baseDeclarationFlags))
                 return true;
         return false;
     }
-    for (const d of base.declarations)
+    for (const d of getDeclarations(base))
         if (!isPropertyAbstractOrInterface(d, baseDeclarationFlags))
             return false;
     return true;
@@ -485,13 +486,13 @@ function checkMemberForOverrideModifier(c, node, staticType, baseStaticType, bas
         return;
     }
     if (baseProp === undefined ||
-        baseProp.declarations.length === 0 ||
+        declarationCount(baseProp) === 0 ||
         memberHasOverrideModifier ||
         c.compilerOptions.noImplicitOverride !== true ||
         (node.flags & 8388608 /* NodeFlags.Ambient */) !== 0)
         return;
     let baseHasAbstract = false;
-    for (const d of baseProp.declarations) {
+    for (const d of getDeclarations(baseProp)) {
         if (hasSyntacticModifier(d, 64 /* ModifierFlags.Abstract */)) {
             baseHasAbstract = true;
             break;
@@ -590,14 +591,14 @@ function checkInheritedPropertiesAreIdentical(c, t, typeNode) {
 // ---- Type parameters of merged declarations
 /** Reports class and interface declarations of one symbol whose type parameters differ. */
 export function checkTypeParameterListsIdentical(c, symbol) {
-    if (symbol.declarations.length === 1)
+    if (declarationCount(symbol) === 1)
         return;
     const links = c.symbolLinks(symbol);
     if (links.typeParametersChecked)
         return;
     links.typeParametersChecked = true;
     const declarations = [];
-    for (const d of symbol.declarations)
+    for (const d of getDeclarations(symbol))
         if (d.kind === 264 /* SyntaxKind.ClassDeclaration */ || d.kind === 265 /* SyntaxKind.InterfaceDeclaration */)
             declarations.push(d);
     if (declarations.length <= 1)
@@ -618,7 +619,7 @@ export function checkTypeParameterListsIdentical(c, symbol) {
 }
 /** Reports the declarations of an `infer` type parameter declared more than once with different constraints. */
 export function checkInferTypeParameterDeclarations(c, symbol) {
-    if (symbol.declarations.length <= 1)
+    if (declarationCount(symbol) <= 1)
         return;
     const links = c.symbolLinks(symbol);
     if (links.typeParametersChecked)
@@ -626,7 +627,7 @@ export function checkInferTypeParameterDeclarations(c, symbol) {
     links.typeParametersChecked = true;
     const declarations = [];
     const typeParameterLists = [];
-    for (const d of symbol.declarations) {
+    for (const d of getDeclarations(symbol)) {
         if (d.kind === 169 /* SyntaxKind.TypeParameter */) {
             declarations.push(d);
             typeParameterLists.push([d]);
@@ -711,7 +712,7 @@ export function checkObjectTypeForDuplicateDeclarations(c, node, checkPrivateNam
     }
 }
 function checkPropertyOrAccessor(c, node, names, symbol, kind, isStaticMember) {
-    if (symbol.declarations.length <= 1)
+    if (declarationCount(symbol) <= 1)
         return;
     const state = names.get(symbol.name) ?? 0 /* MemberKind.None */;
     if (state === 0 /* MemberKind.None */)
@@ -865,12 +866,12 @@ function checkTypeForDuplicateIndexSignatures(c, node) {
     if (symbol === undefined)
         return;
     const indexSymbol = getIndexSymbol(c, symbol);
-    if (indexSymbol === undefined || indexSymbol.declarations.length <= 1)
+    if (indexSymbol === undefined || declarationCount(indexSymbol) <= 1)
         return;
     // Late-bound index signatures may duplicate each other and explicit ones.
     const keyTypes = [];
     const declarationsByKey = [];
-    for (const declaration of indexSymbol.declarations) {
+    for (const declaration of getDeclarations(indexSymbol)) {
         if (declaration.kind !== 182 /* SyntaxKind.IndexSignature */)
             continue;
         const parameters = getParameters(declaration).nodes;

package/dist/api/compiler/checker-inference.d.ts

@@ -1,8 +1,8 @@
 import { type Node } from './ast.js';
-import { type Symbol } from './symbol.js';
 import type { Checker } from './checker.js';
 import { type ConditionalRoot, type IndexType, type MappedType, type ReverseMappedType, type Signature, type TemplateLiteralType, type Type, TypeMapper } from './checker-types.js';
 import { type TypeComparer } from './relations.js';
+import { type Symbol } from './symbol.js';
 export declare const enum InferenceFlags {
     None = 0,
     /** Infer `silentNeverType` for no inferences (otherwise `unknown`). */

package/dist/api/compiler/checker-inference.js

@@ -2,7 +2,6 @@
 // types of type parameters.
 import { sideOf, signatureSideOf } from './side-state.js';
 import { hasSyntacticModifier } from './binder-utilities.js';
-import { getSymbolId } from './symbol.js';
 import { ArrayToSingleTypeMapper, MergedTypeMapper, TupleElementInfo, TypeMapper, newTypeMapper, SimpleTypeMapper, emptyTypes, } from './checker-types.js';
 import { createAnonymousType, createArrayType, createArrayTypeEx, createTupleType, createTupleTypeEx, filterType, getBaseTypeOfLiteralType, getBigIntLiteralType, getElementTypes, getEndElementCount, getIntersectionType, getNumberLiteralType, getRegularTypeOfLiteralType, getStringLiteralType, getTemplateLiteralType, getTypeArguments, getTypeReferenceArity, getUnionType, getUnionTypeEx, getWidenedLiteralType, isArrayOrTupleType, isErrorType, isArrayType, isGenericTupleType, isLiteralType, isMutableArrayOrTuple, isReadonlyArrayType, isTupleType, mapType, newIndexInfo, newObjectType, setStructuredTypeMembers, someType, tupleTargetOf, typesOf, } from './checker-type-factory.js';
 import { getDeclaredTypeOfClassOrInterface, getDeclaredTypeOfSymbol, fillMissingTypeArguments, getConstraintOfTypeParameter, getDefaultFromTypeParameter, getMinTypeArgumentCount, getDeclaredTypeOfTypeParameter, } from './checker-declared-types.js';
@@ -17,6 +16,7 @@ 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 { copyDeclarations, declarationCount, getDeclarations, getSymbolId, } from './symbol.js';
 // Shared empty candidate lists: an InferenceInfo gets its own on its first candidate, as tsgo's nil
 // slices do. Never changed.
 const noCandidates = [];
@@ -179,7 +179,7 @@ function hasTypeParameterDefault(tp) {
     const symbol = tp.symbol;
     if (symbol === undefined)
         return false;
-    for (const d of symbol.declarations)
+    for (const d of getDeclarations(symbol))
         if (d.kind === 169 /* SyntaxKind.TypeParameter */ && d.defaultType !== undefined)
             return true;
     return false;
@@ -991,9 +991,9 @@ function isTopLevelClassStaticSide(t) {
         (symbol.flags &
             (16 /* SymbolFlags.Function */ | 8192 /* SymbolFlags.Method */ | 2048 /* SymbolFlags.TypeLiteral */ | 4096 /* 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 !== 264 /* SyntaxKind.ClassDeclaration */ &&
             d.kind !== 265 /* SyntaxKind.InterfaceDeclaration */ &&
             d.kind !== 268 /* SyntaxKind.ModuleDeclaration */)
@@ -1031,7 +1031,7 @@ function createEmptyObjectTypeFromStringLiteral(c, t) {
         const literalProp = c.newSymbol(4 /* 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);
@@ -1101,7 +1101,7 @@ function typesDefinitelyUnrelated(c, source, target) {
 function hasUnmatchedProperty(c, source, target, matchDiscriminantProperties) {
     const t = getReducedApparentType(c, target);
     if ((t.flags & 402653184 /* TypeFlags.UnionOrIntersection */) === 0 ||
-        sideOf(c, t).resolvedProperties !== undefined)
+        sideOf(c, t).membersOf?.resolvedProperties !== undefined)
         return getUnmatchedProperty(c, source, target, false, matchDiscriminantProperties) !== undefined;
     const containingType = t;
     const isUnion = (t.flags & 134217728 /* TypeFlags.Union */) !== 0;
@@ -1146,7 +1146,7 @@ export function isConstTypeVariable(c, t, depth) {
     if ((t.flags & 524288 /* TypeFlags.TypeParameter */) !== 0) {
         if (t.symbol === undefined)
             return false;
-        for (const d of t.symbol.declarations)
+        for (const d of getDeclarations(t.symbol))
             if (hasSyntacticModifier(d, 4096 /* ModifierFlags.Const */))
                 return true;
         return false;
@@ -1616,7 +1616,7 @@ export function resolveReverseMappedTypeMembers(c, t) {
         }
         const checkFlags = 8192 /* CheckFlags.ReverseMapped */ | (readonlyMask && isReadonlySymbol(c, prop) ? 8 /* CheckFlags.Readonly */ : 0);
         const inferredProp = c.newSymbolWithCheckFlags(4 /* SymbolFlags.Property */ | (prop.flags & optionalMask), 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)));
@@ -2014,7 +2014,7 @@ export function getInferredTypeParameterConstraint(c, t, omitTypeReferences = fa
     const inferences = [];
     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 !== 196 /* SyntaxKind.InferType */)
                 continue;
             let child = declaration.parent;

package/dist/api/compiler/checker-javascript.d.ts

@@ -1,7 +1,7 @@
 import { BinaryExpression, type Node } from './ast.js';
-import { type Symbol } from './symbol.js';
 import type { Checker } from './checker.js';
 import { type Type } from './checker-types.js';
+import { type Symbol } from './symbol.js';
 /** The type of the CommonJS `module` symbol or its `exports` property. */
 export declare function getTypeOfModuleExportsSymbol(c: Checker, symbol: Symbol): Type;
 /** The type of a symbol declared by JavaScript assignments or `Object.defineProperty` calls. */

package/dist/api/compiler/checker-javascript.js

@@ -18,6 +18,7 @@ import { getFlowTypeOfReference, isMatchingReference } from './checker-narrowing
 import { isEmptyArrayLiteralType } from './relations.js';
 import { getTypeOfSymbol, getWidenedType, reportImplicitAny } from './checker-symbol-types.js';
 import { getFlowTypeInConstructor, getFlowTypeOfProperty, getTypeOfPropertyInBaseClass, isAutoTypedProperty, } from './checker-classes.js';
+import { declarationCount, getDeclarations } from './symbol.js';
 /** The type of the CommonJS `module` symbol or its `exports` property. */
 export function getTypeOfModuleExportsSymbol(c, symbol) {
     if (symbol.name === 'exports') {
@@ -39,7 +40,7 @@ export function getWidenedTypeForAssignmentDeclaration(c, symbol) {
         t = getTypeOfPropertyInBaseClass(c, symbol);
     if (t === undefined) {
         const types = [];
-        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.type : undefined;
@@ -170,7 +171,7 @@ function getThisAssignmentKind(c, symbol) {
         return (links.thisAssignmentKind - 1);
     let allThis = true;
     let typeAnnotation;
-    for (const declaration of symbol.declarations) {
+    for (const declaration of getDeclarations(symbol)) {
         if (!(declaration instanceof BinaryExpression)) {
             allThis = false;
             break;
@@ -210,7 +211,7 @@ export function isConstructorDeclaredThisProperty(c, symbol) {
     return getThisAssignmentKind(c, symbol) === 2 /* ThisAssignmentKind.Constructor */;
 }
 function getDeclaringConstructor(symbol) {
-    for (const declaration of symbol.declarations) {
+    for (const declaration of getDeclarations(symbol)) {
         const container = getThisContainer(declaration, false, false);
         if (container.kind === 177 /* SyntaxKind.Constructor */)
             return container;
@@ -437,5 +438,5 @@ export function isUndefinedAssignmentToCommonJSExport(c, left, rightType) {
     if (getAssignmentDeclarationKind(assignment) !== 2 /* JSDeclarationKind.ExportsProperty */)
         return false;
     const symbol = c.resolvedSymbols.get(left.id);
-    return symbol !== undefined && symbol.declarations.length > 1 && (rightType.flags & 4 /* TypeFlags.Undefined */) !== 0;
+    return symbol !== undefined && declarationCount(symbol) > 1 && (rightType.flags & 4 /* TypeFlags.Undefined */) !== 0;
 }

package/dist/api/compiler/checker-jsx.d.ts

@@ -1,11 +1,11 @@
 import { type JsxAttributes, type Node, type SourceFile } from './ast.js';
 import { Diagnostic } from './diagnostics.js';
-import { type Symbol } from './symbol.js';
 import { type Checker } from './checker.js';
 import { CheckMode, type Signature, type Type } from './checker-types.js';
 import { type Relation } from './relations.js';
 import { ContextFlags } from './checker-contextual.js';
 import { type InferenceContext } from './checker-inference.js';
+import { type Symbol } from './symbol.js';
 declare const enum JsxFlags {
     None = 0,
     /** An element from a named property of `JSX.IntrinsicElements`. */

package/dist/api/compiler/checker-jsx.js

@@ -6,7 +6,6 @@ import { Diagnostic, chainDiagnostic } from './diagnostics.js';
 import { JsxEmit } from './options.js';
 import { parseIsolatedEntityName } from './parser.js';
 import { skipTrivia } from './scanner.js';
-import { getSymbolId } from './symbol.js';
 import { createDiagnosticForNode } from './checker.js';
 import { newTypeMapper, } from './checker-types.js';
 import { createAnonymousType, createArrayType, createTupleType, createTypeReference, getIntersectionType, getPropagatingFlagsOfTypes, getStringLiteralType, getUnionType, intersectTypes, isErrorType, everyType, isArrayType, mapTypeEx, someType, typesOf, } from './checker-type-factory.js';
@@ -38,6 +37,7 @@ 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, } from './symbol.js';
 // Names in the `JSX` namespace.
 const jsxNamespaceName = 'JSX';
 const jsxIntrinsicElementsName = 'IntrinsicElements';
@@ -384,8 +384,8 @@ function getNameFromJsxElementAttributesContainer(c, containerName, ns) {
                 return '';
             if (props.length === 1)
                 return props[0].name;
-            if (sym.declarations.length !== 0)
-                c.error(sym.declarations[0], 752 /* Diagnostics.The_global_type_JSX_0_may_not_have_more_than_one_property */, containerName);
+            if (declarationCount(sym) !== 0)
+                c.error(sym.declaration, 752 /* Diagnostics.The_global_type_JSX_0_may_not_have_more_than_one_property */, containerName);
         }
     }
     return "\uFFFEmissing" /* InternalSymbolName.Missing */;
@@ -733,7 +733,7 @@ export function createJsxAttributesTypeFromAttributesProperty(c, openingLikeElem
                 const exprType = checkJsxAttribute(c, attributeDecl, checkMode);
                 objectFlags |= exprType.objectFlags & 458752 /* ObjectFlags.PropagatingFlags */;
                 const attributeSymbol = c.newSymbol(4 /* 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;

package/dist/api/compiler/checker-literals.js

@@ -1,4 +1,4 @@
-import { getSymbolId } from './symbol.js';
+import { copyDeclarations, getSymbolId } from './symbol.js';
 import { cachedTypeKey } from './checker-types.js';
 import { createAnonymousType } from './checker-type-factory.js';
 import { getPropertiesOfObjectType, resolveStructuredTypeMembers } from './checker-members.js';
@@ -29,7 +29,7 @@ export function getRegularTypeOfObjectLiteral(c, t) {
 }
 function createSymbolWithTypeLocal(c, source, t) {
     const symbol = c.newSymbolWithCheckFlags(source.flags, source.name, source.checkFlags & 8 /* CheckFlags.Readonly */);
-    symbol.declarations = source.declarations;
+    copyDeclarations(symbol, source);
     symbol.parent = source.parent;
     symbol.valueDeclaration = source.valueDeclaration;
     const id = getSymbolId(symbol);