tsc-ts 0.0.5 → 0.0.7

package/dist/api/compiler/binder.js

@@ -3,14 +3,14 @@
 //
 // Fields of `instanceof`-narrowed nodes are read through `as` casts: scriptc reads them
 // statically, but reads fields of a narrowed value dynamically.
-import { BinaryExpression, CallExpression, ConditionalTypeNode, ElementAccessExpression, ExportAssignment, FunctionExpression, KeywordExpression, ModuleDeclaration, NodeVisitor, PatternAmbientModule, PrefixUnaryExpression, PropertyAccessExpression, TypeAliasDeclaration, VariableDeclaration, getArguments, getBody, getElements, getExpression, getInitializer, getLabel, getLocals, getModifiers, getName, getParameters, getPostfixToken, getProperties, getStatements, getSymbol, getText, isDeclarationNode, isLocalsContainer, setEndFlowNode, setFlowNode, setLocalSymbol, setLocals, setNextContainer, setReturnFlowNode, setSymbol, } from './ast.js';
+import { appendToList, BinaryExpression, CallExpression, ConditionalTypeNode, ElementAccessExpression, ExportAssignment, FunctionExpression, KeywordExpression, ModuleDeclaration, NodeVisitor, PatternAmbientModule, PrefixUnaryExpression, PropertyAccessExpression, ReferenceIdentifier, TypeAliasDeclaration, VariableDeclaration, getArguments, getBody, getElements, getExpression, getInitializer, getLabel, getLocals, getModifiers, getName, getParameters, getPostfixToken, getProperties, getStatements, getSymbol, getText, isDeclarationNode, isLocalsContainer, setEndFlowNode, setFlowNode, setLocalSymbol, setLocals, setNextContainer, setReturnFlowNode, setSymbol, callQuestionDotToken, callTypeArguments, } from './ast.js';
 import { isAmbientModule, isAssignmentOperator, isFunctionLike, isGlobalScopeAugmentation, isInJSFile, isLeftHandSideExpression, isRequireCall, isStringLiteralLike, nodeIsMissing, nodeIsPresent, } from './ast-utilities.js';
 import { declarationNameToString, expressionIsAlias, getAssignmentDeclarationKind, getCombinedModifierFlags, getContainingClass, getElementOrPropertyAccessName, getErrorRangeForNode, getImmediatelyInvokedFunctionExpression, getModuleInstanceState, StatementsByName, getNameOfDeclaration, getRangeOfTokenAtPosition, getSourceTextOfNode, hasDynamicName, hasSyntacticModifier, isAssignmentTarget, isAsyncFunction, isAutoAccessorPropertyDeclaration, isBlockOrCatchScoped, isBooleanLiteral, isDeclarationStatementKind, isDestructuringAssignment, isDottedName, isEntityNameExpression, isEnumConst, isExpandoInitializer, isExpressionOfOptionalChainRoot, isExternalModule, isExternalOrCommonJSModule, isIdentifierName, isImplicitlyExportedJSDocDeclaration, isInTopLevelContext, isJsonSourceFile, isLogicalExpression, isLogicalOrCoalescingAssignmentExpression, isLogicalOrCoalescingAssignmentOperator, isLogicalOrCoalescingBinaryOperator, isModuleAugmentationExternal, isNullishCoalesce, isObjectLiteralMethod, isObjectLiteralOrClassExpressionMethodOrAccessor, isOptionalChain, isOptionalChainRoot, isOutermostOptionalChain, isParameterPropertyDeclaration, isPartOfParameterDeclaration, isPartOfTypeQuery, isPotentiallyExecutableNode, isPrologueDirective, isPropertyNameLiteral, isPushOrUnshiftIdentifier, isSignedNumericLiteral, isStatic, isStringOrNumericLiteralLike, isVariableDeclarationInitializedToRequire, moduleExportNameIsDefault, nodeText, skipParentheses, } from './binder-utilities.js';
 import { Diagnostic } from './diagnostics.js';
 import { FlowNode, FlowReduceLabel, FlowSwitchClause } from './flow.js';
 import { removeFileExtension } from './path.js';
 import { getIdentifierToken, tokenToString } from './scanner.js';
-import { Symbol, addDeclaration, getExports, getMembers, getSymbolId, internalSymbolNamePrefix, } from './symbol.js';
+import { addDeclaration, copyDeclarations, declarationCount, getDeclarations, getExports, getMembers, getSymbolId, internalSymbolNamePrefix, Symbol, } from './symbol.js';
 export function getContainerFlags(node) {
     switch (node.kind) {
         case 232 /* SyntaxKind.ClassExpression */:
@@ -306,7 +306,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.isExportEquals)) {
                 message = 686 /* Diagnostics.A_module_cannot_have_multiple_default_exports */;
@@ -325,7 +325,7 @@ class Binder extends NodeVisitor {
                 'export type { ' + node.name.text + ' }',
             ]));
         }
-        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;
@@ -498,7 +498,7 @@ class Binder extends NodeVisitor {
     addDeclarationToSymbol(symbol, node, symbolFlags) {
         symbol.flags |= symbolFlags;
         setSymbol(node, symbol);
-        if (symbol.declarations.indexOf(node) < 0)
+        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 & 268435456 /* SymbolFlags.ConstEnumOnlyModule */) !== 0 &&
@@ -541,7 +541,7 @@ class Binder extends NodeVisitor {
         this.addDiagnostic(new Diagnostic(this.file.diagnosticFile(), range.pos, range.end, message, args));
     }
     addDiagnostic(diagnostic) {
-        this.file.bindDiagnostics.push(diagnostic);
+        this.file.bindDiagnostics = appendToList(this.file.bindDiagnostics, diagnostic);
     }
     // Traversal
     bindOptional(node) {
@@ -553,7 +553,8 @@ class Binder extends NodeVisitor {
         // the container's locals; anonymous declarations like type literals go in no table.
         switch (node.kind) {
             case 79 /* SyntaxKind.Identifier */:
-                node.flowNode = this.currentFlowValue();
+                if (node instanceof ReferenceIdentifier)
+                    node.flowNode = this.currentFlowValue();
                 this.checkContextualIdentifier(node);
                 break;
             case 109 /* SyntaxKind.ThisKeyword */:
@@ -906,7 +907,7 @@ class Binder extends NodeVisitor {
         symbol.valueDeclaration = this.file;
         if (name === 'module') {
             const exportsProperty = this.newSymbol(134217728 /* SymbolFlags.ModuleExports */ | 4 /* SymbolFlags.Property */, 'exports');
-            exportsProperty.declarations = symbol.declarations;
+            copyDeclarations(exportsProperty, symbol);
             exportsProperty.valueDeclaration = this.file;
             exportsProperty.parent = symbol;
             getMembers(symbol).set('exports', exportsProperty);
@@ -1618,8 +1619,8 @@ class Binder extends NodeVisitor {
             this.bind(node.argumentExpression);
         }
         else if (node instanceof CallExpression) {
-            this.bindOptional(node.questionDotToken);
-            this.bindNodes(node.typeArguments);
+            this.bindOptional(callQuestionDotToken(node));
+            this.bindNodes(callTypeArguments(node));
             this.bindNodes(node.arguments);
         }
     }
@@ -1630,7 +1631,7 @@ class Binder extends NodeVisitor {
             // An IIFE's flow node includes the evaluation of its arguments.
             const callee = skipParentheses(node.expression);
             if (callee.kind === 219 /* SyntaxKind.FunctionExpression */ || callee.kind === 220 /* SyntaxKind.ArrowFunction */) {
-                this.bindNodes(node.typeArguments);
+                this.bindNodes(callTypeArguments(node));
                 this.bindNodes(node.arguments);
                 this.bind(node.expression);
             }
@@ -1696,7 +1697,7 @@ class Binder extends NodeVisitor {
                 if (starIndex >= 0 && text.indexOf('*', starIndex + 1) >= 0)
                     this.errorOnFirstToken(name, 1136 /* 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;
         }
@@ -1806,7 +1807,7 @@ class Binder extends NodeVisitor {
         const exports = getExports(symbol);
         const existing = exports.get('prototype');
         if (existing !== undefined)
-            this.errorOnNode(existing.declarations[0], 478 /* Diagnostics.Duplicate_identifier_0 */, ['prototype']);
+            this.errorOnNode(existing.declaration, 478 /* Diagnostics.Duplicate_identifier_0 */, ['prototype']);
         exports.set('prototype', prototypeSymbol);
         prototypeSymbol.parent = symbol;
     }

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

@@ -1,7 +1,7 @@
 // Calls, `new` and tagged templates: signature resolution with type argument inference and overload
 // selection, argument checks and resolution errors.
 import { checkDeprecatedSignature } from './checker-deprecation.js';
-import { Node, getArguments as getArgumentList, getExpression, getName, getParameters, getText, getTypeArguments as getTypeArgumentList, getNodeId, getBody, getSymbol, } from './ast.js';
+import { Node, getArguments as getArgumentList, getExpression, getName, getParameters, getText, getTypeArguments as getTypeArgumentList, getNodeId, getBody, getSymbol, callQuestionDotToken, callTypeArguments, } from './ast.js';
 import { canHaveDecorators, getEffectiveCheckNode, isFunctionLikeDeclarationKind, isImportCall, nodeIsPresent, } from './ast-utilities.js';
 import { getContainingClass, getSourceFileOfNode, isAccessExpression, isExpressionOfOptionalChainRoot, isOptionalChain, isOutermostOptionalChain, isDottedName, } from './binder-utilities.js';
 import { Diagnostic, chainDiagnostic } from './diagnostics.js';
@@ -38,6 +38,7 @@ import { getGlobalValueSymbol, getSymbolOfDeclaration, resolveName } from './che
 import { checkImportCallExpression } from './checker-modules.js';
 import { checkApplicableSignatureForJsxCallLikeElement, getAttributesOf, getEffectiveJsxArguments, inferJsxTypeArguments, isJsxOpeningLikeElement, resolveJsxOpeningLikeElement, } from './checker-jsx.js';
 import { isCommonJSRequire, resolveExternalModuleTypeByLiteral } from './checker-javascript.js';
+import { declarationCount, getDeclarations } from './symbol.js';
 /** The type of an optional chain's expression with the chain's `undefined` removed. */
 export function getOptionalExpressionType(c, exprType, expression) {
     if (isExpressionOfOptionalChainRoot(expression))
@@ -71,7 +72,7 @@ export function checkCallExpression(c, node, checkMode) {
     if ((returnType.flags & 16896 /* TypeFlags.ESSymbolLike */) !== 0 && isSymbolOrSymbolForCall(c, call))
         return getESSymbolLikeTypeForNode(c, walkUpParenthesizedExpressions(node.parent));
     // An assertion call must name its target through explicitly typed declarations.
-    if (call.questionDotToken === undefined &&
+    if (callQuestionDotToken(call) === undefined &&
         node.parent.kind === 245 /* SyntaxKind.ExpressionStatement */ &&
         (returnType.flags & 16 /* TypeFlags.Void */) !== 0 &&
         getTypePredicateOfSignature(c, signature) !== undefined) {
@@ -195,7 +196,7 @@ function resolveCallExpression(c, node, checkMode) {
     const callSignatures = getSignaturesOfType(c, apparentType, 0 /* SignatureKind.Call */);
     const numConstructSignatures = getSignaturesOfType(c, apparentType, 1 /* 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, 523 /* Diagnostics.Untyped_function_calls_may_not_accept_type_arguments */);
         return resolveUntypedCall(c, node);
     }
@@ -209,7 +210,7 @@ function resolveCallExpression(c, node, checkMode) {
     // An inner generic call returning a function is deferred while an outer call infers, so that
     // inferences can flow through function composition.
     if ((checkMode & 8 /* CheckMode.SkipGenericFunctions */) !== 0 &&
-        node.typeArguments === undefined &&
+        callTypeArguments(node) === undefined &&
         someGenericFunctionReturningFunction(c, callSignatures)) {
         skippedGenericFunction(c, node, checkMode);
         return c.resolvingSignature;
@@ -1246,10 +1247,10 @@ function reportCallResolutionErrors(c, s, signatures, headMessage) {
 /** Notes when the call would have resolved to the implementation signature of the overloads. */
 function addImplementationSuccessElaboration(c, s, failed, diagnostic) {
     const symbol = failed.declaration !== undefined ? getSymbol(failed.declaration) : undefined;
-    if (symbol === undefined || symbol.declarations.length <= 1)
+    if (symbol === undefined || declarationCount(symbol) <= 1)
         return;
     let implementation;
-    for (const d of symbol.declarations) {
+    for (const d of getDeclarations(symbol)) {
         if (isFunctionLikeDeclarationKind(d.kind) && nodeIsPresent(getBody(d))) {
             implementation = d;
             break;

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

@@ -110,7 +110,7 @@ export function checkExpressionWithContextualType(c, node, contextualType, infer
     let t = checkExpressionEx(c, node, checkMode | 1 /* CheckMode.Contextual */ | (inferenceContext !== undefined ? 2 /* CheckMode.Inferential */ : 0));
     // Intra-expression inference sites only matter during this check.
     if (inferenceContext !== undefined)
-        inferenceContext.intraExpressionInferenceSites = [];
+        inferenceContext.intraExpressionInferenceSites = undefined;
     // Contextually typed literals keep their literal types rather than widening during inference.
     if (maybeTypeOfKind(t, 15360 /* TypeFlags.Literal */) &&
         isLiteralOfContextualType(c, t, instantiateContextualType(c, contextualType, node, 0 /* ContextFlags.None */)))

package/dist/api/compiler/checker-declaration-order.js

@@ -12,6 +12,7 @@ import { getExportSymbolOfValueSymbolIfExported } from './checker-symbols.js';
 import { getBaseTypes, getDeclaredTypeOfSymbol } from './checker-declared-types.js';
 import { getPropertyOfType } from './checker-members.js';
 import { getFunctionFlags } from './checker-utilities.js';
+import { getDeclarations } from './symbol.js';
 /** Reports a block-scoped variable, class or enum resolved at `errorLocation` before its declaration. */
 export function checkResolvedBlockScopedVariable(c, resolved, errorLocation) {
     const result = getExportSymbolOfValueSymbolIfExported(c, resolved);
@@ -22,7 +23,7 @@ export function checkResolvedBlockScopedVariable(c, resolved, errorLocation) {
         (result.flags & 32 /* SymbolFlags.Class */) !== 0)
         return;
     let declaration;
-    for (const d of result.declarations) {
+    for (const d of getDeclarations(result)) {
         if (isBlockOrCatchScoped(d) || isClassLike(d) || d.kind === 267 /* SyntaxKind.EnumDeclaration */) {
             declaration = d;
             break;

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

@@ -11,7 +11,6 @@ import { getPropertyNameFromType, isBindingPattern, isTypeUsableAsPropertyName }
 import { checkPropertyAccessibility } from './checker-property-access.js';
 import { declarationNameToString, getNameOfDeclaration, getSourceFileOfNode, getAssignmentDeclarationKind, getCombinedModifierFlags, getCombinedNodeFlags, isPartOfParameterDeclaration, getRootDeclaration, getDeclarationOfKind, getModifierFlags, getModuleInstanceState, getRangeOfTokenAtPosition, hasSyntacticModifier, isEntityNameExpression, isEnumConst, isExternalModule, isModuleAugmentationExternal, isVariableDeclarationInitializedToRequire, isClassLike, } from './binder-utilities.js';
 import { Diagnostic } from './diagnostics.js';
-import { getSymbolId } from './symbol.js';
 import { createDiagnosticForNode } from './checker.js';
 import { getLiteralTypeFromPropertyName, intrinsicTypeKind } from './checker-type-operators.js';
 import { SimpleTypeMapper, } from './checker-types.js';
@@ -36,6 +35,7 @@ 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, } from './symbol.js';
 // ---- Variables and parameters
 export function checkVariableStatement(c, node) {
     checkVariableDeclarationList(c, node.declarationList);
@@ -126,8 +126,8 @@ export function checkVariableLikeDeclaration(c, node) {
             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;
@@ -552,15 +552,15 @@ export function checkEnumDeclaration(c, node) {
     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 === 267 /* SyntaxKind.EnumDeclaration */ && isEnumConst(d) !== enumIsConst)
                 c.error(getNameOfDeclaration(d), 637 /* 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 !== 267 /* SyntaxKind.EnumDeclaration */)
             continue;
         const members = d.members.nodes;
@@ -606,7 +606,7 @@ export function checkModuleDeclaration(c, node) {
         // Namespaces of global scripts can merge across files, which a transpiler of one file cannot see.
         if (c.isolatedModules && getSourceFileOfNode(node).externalModuleIndicator === undefined)
             c.error(module.name, 229 /* 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))
@@ -648,7 +648,7 @@ export function isInstantiatedModule(node, preserveConstEnums) {
     return (state === 2 /* ModuleInstanceState.Instantiated */ || (preserveConstEnums && state === 3 /* ModuleInstanceState.ConstEnumOnly */));
 }
 function getFirstNonAmbientClassOrFunctionDeclaration(symbol) {
-    for (const d of symbol.declarations)
+    for (const d of getDeclarations(symbol))
         if ((d.kind === 264 /* SyntaxKind.ClassDeclaration */ ||
             (d.kind === 263 /* SyntaxKind.FunctionDeclaration */ && nodeIsPresent(getBody(d)))) &&
             (d.flags & 8388608 /* NodeFlags.Ambient */) === 0)
@@ -719,7 +719,7 @@ export function checkExternalModuleExports(c, node) {
         if (id === "\uFFFEexport" /* InternalSymbolName.ExportStar */ || (symbol.flags & (1920 /* SymbolFlags.Namespace */ | 384 /* 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 !== 265 /* SyntaxKind.InterfaceDeclaration */)
                 count++;
         // A type alias may merge with one value.
@@ -728,12 +728,12 @@ export function checkExternalModuleExports(c, node) {
         if (count <= 1)
             continue;
         let allExportsProperties = true;
-        for (const d of symbol.declarations)
+        for (const d of getDeclarations(symbol))
             if (getAssignmentDeclarationKind(d) !== 2 /* 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, 501 /* Diagnostics.Cannot_redeclare_exported_variable_0 */, id);
     }
@@ -780,7 +780,7 @@ export function checkExportsOnMergedDeclarations(c, node) {
     let exported = 0 /* DeclarationSpaces.None */;
     let nonExported = 0 /* DeclarationSpaces.None */;
     let defaultExported = 0 /* DeclarationSpaces.None */;
-    for (const d of symbol.declarations) {
+    for (const d of getDeclarations(symbol)) {
         const spaces = getDeclarationSpaces(c, d);
         const flags = getEffectiveDeclarationFlags(d, 32 /* ModifierFlags.Export */ | 2048 /* ModifierFlags.Default */);
         if ((flags & 32 /* ModifierFlags.Export */) !== 0) {
@@ -797,7 +797,7 @@ export function checkExportsOnMergedDeclarations(c, node) {
     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);
@@ -847,7 +847,7 @@ function getAliasDeclarationSpaces(c, node) {
     if (symbol === undefined)
         return 0 /* DeclarationSpaces.None */;
     let result = 0 /* DeclarationSpaces.None */;
-    for (const d of resolveAlias(c, symbol).declarations)
+    for (const d of getDeclarations(resolveAlias(c, symbol)))
         result |= getDeclarationSpaces(c, d);
     return result;
 }

package/dist/api/compiler/checker-declared-types.d.ts

@@ -1,10 +1,10 @@
 import { type Node } from './ast.js';
 import { getSourceFileOfNode } from './binder-utilities.js';
-import { type Symbol } from './symbol.js';
 import { SyntaxKind } from './syntax-kind.js';
 import { type Checker } from './checker.js';
 import { InterfaceType, type LiteralType, type Signature, type Type, TypeParameter } from './checker-types.js';
 import { getFirstIdentifier, getMergedSymbol, getParentOfSymbol } from './checker-symbols.js';
+import { type Symbol } from './symbol.js';
 export { getParentOfSymbol };
 export declare function getDeclaredTypeOfSymbol(c: Checker, symbol: Symbol): Type;
 export declare function tryGetDeclaredTypeOfSymbol(c: Checker, symbol: Symbol): Type | undefined;

package/dist/api/compiler/checker-declared-types.js

@@ -20,6 +20,7 @@ import { getIndexedAccessType, isGenericMappedType } from './checker-type-operat
 import { getSignatureInstantiation } from './checker-signatures.js';
 import { evaluateEnumMember } from './checker-evaluator.js';
 import { checkTypeAssignableTo, isTypeIdenticalTo } from './relations.js';
+import { getDeclarations } from './symbol.js';
 export { getParentOfSymbol };
 export function getDeclaredTypeOfSymbol(c, symbol) {
     return tryGetDeclaredTypeOfSymbol(c, symbol) ?? c.errorType;
@@ -82,7 +83,7 @@ export function getDeclaredTypeOfClassOrInterface(c, symbol) {
     return links.declaredType;
 }
 function isThislessInterface(c, symbol) {
-    for (const declaration of symbol.declarations) {
+    for (const declaration of getDeclarations(symbol)) {
         if (declaration.kind !== 265 /* SyntaxKind.InterfaceDeclaration */)
             continue;
         if ((declaration.flags & 128 /* NodeFlags.ContainsThis */) !== 0)
@@ -127,7 +128,7 @@ export function getExtendsHeritageClauseElement(node) {
     return elements.length !== 0 ? elements[0] : undefined;
 }
 export function getClassLikeDeclarationOfSymbol(symbol) {
-    for (const d of symbol.declarations)
+    for (const d of getDeclarations(symbol))
         if (d.kind === 264 /* SyntaxKind.ClassDeclaration */ || d.kind === 232 /* SyntaxKind.ClassExpression */)
             return d;
     return undefined;
@@ -136,7 +137,7 @@ function getOuterTypeParametersOfClassOrInterface(c, symbol) {
     let declaration = symbol.valueDeclaration;
     if ((symbol.flags & (32 /* SymbolFlags.Class */ | 16 /* SymbolFlags.Function */)) === 0) {
         declaration = undefined;
-        for (const d of symbol.declarations) {
+        for (const d of getDeclarations(symbol)) {
             if (d.kind === 265 /* SyntaxKind.InterfaceDeclaration */) {
                 declaration = d;
                 break;
@@ -227,7 +228,7 @@ export function getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(c, symbol) {
     return appendLocalTypeParameters(c, [], symbol);
 }
 function appendLocalTypeParameters(c, types, symbol) {
-    for (const node of symbol.declarations) {
+    for (const node of getDeclarations(symbol)) {
         if (node.kind === 265 /* SyntaxKind.InterfaceDeclaration */ ||
             node.kind === 264 /* SyntaxKind.ClassDeclaration */ ||
             node.kind === 232 /* SyntaxKind.ClassExpression */ ||
@@ -259,7 +260,7 @@ export function getDeclaredTypeOfTypeAlias(c, symbol) {
     if (!pushTypeResolution(c, symbol, 2 /* TypeSystemPropertyName.DeclaredType */))
         return c.errorType;
     let declaration;
-    for (const d of symbol.declarations)
+    for (const d of getDeclarations(symbol))
         if (d.kind === 266 /* SyntaxKind.TypeAliasDeclaration */ || d.kind === 345 /* SyntaxKind.JSTypeAliasDeclaration */) {
             declaration = d;
             break;
@@ -292,7 +293,7 @@ export function getDeclaredTypeOfEnum(c, symbol) {
     if (links.declaredType !== undefined)
         return links.declaredType;
     const memberTypes = [];
-    for (const declaration of symbol.declarations) {
+    for (const declaration of getDeclarations(symbol)) {
         if (declaration.kind !== 267 /* SyntaxKind.EnumDeclaration */)
             continue;
         for (const member of declaration.members.nodes) {
@@ -454,7 +455,7 @@ export function getBaseTypes(c, t) {
                 resolveBaseTypesOfInterface(c, t);
         }
         if (!popTypeResolution(c))
-            for (const declaration of t.symbol.declarations)
+            for (const declaration of getDeclarations(t.symbol))
                 if (declaration.kind === 264 /* SyntaxKind.ClassDeclaration */ || declaration.kind === 265 /* SyntaxKind.InterfaceDeclaration */)
                     reportCircularBaseType(c, declaration, t);
         // Circular defaults may leave members partially resolved; reset them.
@@ -528,7 +529,7 @@ function isInJS(node) {
     return (node.flags & 65536 /* NodeFlags.JavaScriptFile */) !== 0;
 }
 function resolveBaseTypesOfInterface(c, t) {
-    for (const declaration of t.symbol.declarations) {
+    for (const declaration of getDeclarations(t.symbol)) {
         if (declaration.kind !== 265 /* SyntaxKind.InterfaceDeclaration */)
             continue;
         for (const node of getExtendsHeritageClauseElements(declaration)) {
@@ -666,7 +667,7 @@ export function hasNonCircularBaseConstraint(c, t) {
 }
 export function getConstraintDeclaration(t) {
     if (t.symbol !== undefined)
-        for (const d of t.symbol.declarations)
+        for (const d of getDeclarations(t.symbol))
             if (d.kind === 169 /* SyntaxKind.TypeParameter */) {
                 const constraint = d.constraint;
                 if (constraint !== undefined)
@@ -723,7 +724,7 @@ export function getResolvedTypeParameterDefault(c, t) {
             side.resolvedDefaultType = c.resolvingDefaultType;
             let defaultType = c.noConstraintType;
             if (t.symbol !== undefined)
-                for (const d of t.symbol.declarations)
+                for (const d of getDeclarations(t.symbol))
                     if (d.kind === 169 /* SyntaxKind.TypeParameter */) {
                         const node = d.defaultType;
                         if (node !== undefined) {
@@ -753,7 +754,7 @@ export function getMinTypeArgumentCount(c, typeParameters) {
 function hasTypeParameterDefault(t) {
     if (t.symbol === undefined)
         return false;
-    for (const d of t.symbol.declarations)
+    for (const d of getDeclarations(t.symbol))
         if (d.kind === 169 /* SyntaxKind.TypeParameter */ && d.defaultType !== undefined)
             return true;
     return false;

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

@@ -5,7 +5,6 @@ import { checkDeprecatedSignature } from './checker-deprecation.js';
 import { FunctionTypeNode, KeywordTypeNode, NodeList, getBody, getDotDotDotToken, getModifiers, getName, getParameters, getText, getType, getInitializer, getMembers, } from './ast.js';
 import { canHaveDecorators } from './ast-utilities.js';
 import { getDeclarationOfKind, getSourceFileOfNode, getSourceTextOfNode, hasStaticModifier, hasSyntacticModifier, isClassLike, isStatic, isPrivateIdentifierClassElementDeclaration, isAutoAccessorPropertyDeclaration, } from './binder-utilities.js';
-import { getSymbolId } from './symbol.js';
 import { createDiagnosticForNode } from './checker.js';
 import { ModuleKind, getEmitModuleKind, ScriptTarget, getUseDefineForClassFields } from './options.js';
 import { getFirstConstructorWithBody, getRestParameterElementType, classElementOrClassElementParameterIsDecorated, classOrConstructorParameterIsDecorated, } from './transformers/decorator-utilities.js';
@@ -20,6 +19,7 @@ import { getOrCreateTypeFromSignature, getParameterCount, getReturnTypeOfSignatu
 import { checkTypeAssignableTo } from './relations.js';
 import { getResolvedSignature } from './checker-calls.js';
 import { getGlobalClassAccessorDecoratorContextType, getGlobalClassAccessorDecoratorResultType, getGlobalClassAccessorDecoratorTargetType, getGlobalClassDecoratorContextType, getGlobalClassFieldDecoratorContextType, getGlobalClassGetterDecoratorContextType, getGlobalClassMethodDecoratorContextType, getGlobalClassSetterDecoratorContextType, getGlobalTypedPropertyDescriptorType, } from './checker-globals.js';
+import { getDeclarations, getSymbolId } from './symbol.js';
 // ---- Checks
 /** Resolves the decorators of `node` as calls and checks their return types. */
 export function checkDecorators(c, node) {
@@ -160,10 +160,10 @@ function checkMetadataTypeImport(c, typeNode) {
     const rootSymbol = resolveName(c, rootName, getText(rootName), meaning, undefined, true, false);
     if (rootSymbol === undefined || (rootSymbol.flags & 2097152 /* SymbolFlags.Alias */) === 0 || symbolIsValue(c, rootSymbol))
         return;
-    if (rootSymbol.declarations.some(isTypeOnlyImportOrExportDeclaration))
+    if (getDeclarations(rootSymbol).some(isTypeOnlyImportOrExportDeclaration))
         return;
     const diagnostic = c.error(typeName, 221 /* 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, 305 /* Diagnostics.X_0_was_imported_here */, [getText(rootName)]));
 }

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;