tsc-ts 0.0.5 → 0.0.7

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

@@ -1,12 +1,26 @@
 import { type Node, type SourceFile } from './ast.js';
 import { type DiagnosticMessage } from './diagnostics.js';
 import { ModuleKind } from './options.js';
-import { type Symbol, SymbolFlags, type SymbolTable } from './symbol.js';
 import { type Checker, type CheckerHost } from './checker.js';
 import { type Type } from './checker-types.js';
+import { type Symbol, SymbolFlags, type SymbolTable } from './symbol.js';
 /** The module symbol `moduleReference` names, reporting it when it isn't found unless `ignoreErrors`. */
 export declare function resolveExternalModuleName(c: Checker, location: Node, moduleReference: Node | undefined, ignoreErrors: boolean): Symbol | undefined;
 export declare function resolveExternalModuleNameWorker(c: Checker, location: Node, moduleReference: Node | undefined, moduleNotFoundError: DiagnosticMessage | undefined, ignoreErrors: boolean, isForAugmentation: boolean): Symbol | undefined;
+/** A `resolveExternalModule` result that reported nothing, and the arguments it was computed for. */
+export declare class ModuleResolution {
+    readonly moduleReference: string;
+    readonly moduleNotFoundError: DiagnosticMessage | undefined;
+    readonly isForAugmentation: boolean;
+    readonly symbol: Symbol | undefined;
+    constructor(moduleReference: string, moduleNotFoundError: DiagnosticMessage | undefined, isForAugmentation: boolean, symbol: Symbol | undefined);
+}
+/**
+ * The module symbol `moduleReference` resolves to from `location`, reporting resolution errors at
+ * `errorNode`. Each name an import or export declaration lists resolves its module specifier again,
+ * with the same result and the same diagnostics: a result that reported nothing is kept for the
+ * specifier and returned to later calls from the same declaration (`sharesSpecifierContext`).
+ */
 export declare function resolveExternalModule(c: Checker, location: Node, moduleReference: string, moduleNotFoundError: DiagnosticMessage | undefined, errorNode: Node | undefined, isForAugmentation: boolean): Symbol | undefined;
 /** A message with its arguments, the elaboration of a diagnostic before it has a location. */
 export declare class DiagnosticDetails {

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

@@ -15,7 +15,6 @@ import { getResolutionModeOverride, moduleKindName } from './program-utilities.j
 import { hasExtension } from './vfs-match.js';
 import { isNodeCoreModule } from './parser.js';
 import { combinePaths, extensionIsTs, fileExtensionIsOneOf, getDeclarationFileExtension, getDirectoryPath, getNormalizedAbsolutePath, isDeclarationFileName, isExternalModuleNameRelative, pathIsRelative, removeExtension, supportedTSExtensionsFlat, tryExtractTSExtension, tryGetExtensionFromPath, } from './path.js';
-import { getSymbolId } from './symbol.js';
 import { isExpressionNode } from './transformers/alias-references.js';
 import { createDiagnosticForNode } from './checker.js';
 import { checkExternalEmitHelpers } from './checker-emit-helpers.js';
@@ -35,6 +34,7 @@ import { createPromiseType } from './checker-iteration.js';
 import { symbolToString, typeToString } from './type-printer.js';
 import { checkTypeAssignableToAndOptionallyElaborate } from './checker-expressions.js';
 import { grammarErrorOnNode } from './checker-operators.js';
+import { declarationAt, declarationCount, getDeclarations, getSymbolId, setDeclarations, } from './symbol.js';
 // ---- Resolution
 /** The module symbol `moduleReference` names, reporting it when it isn't found unless `ignoreErrors`. */
 export function resolveExternalModuleName(c, location, moduleReference, ignoreErrors) {
@@ -57,7 +57,78 @@ export function resolveExternalModuleNameWorker(c, location, moduleReference, mo
         return undefined;
     return resolveExternalModule(c, location, getText(moduleReference), moduleNotFoundError, ignoreErrors ? undefined : moduleReference, isForAugmentation);
 }
+/** A `resolveExternalModule` result that reported nothing, and the arguments it was computed for. */
+export class ModuleResolution {
+    moduleReference;
+    moduleNotFoundError;
+    isForAugmentation;
+    symbol;
+    constructor(moduleReference, moduleNotFoundError, isForAugmentation, symbol) {
+        this.moduleReference = moduleReference;
+        this.moduleNotFoundError = moduleNotFoundError;
+        this.isForAugmentation = isForAugmentation;
+        this.symbol = symbol;
+    }
+}
+/**
+ * The module symbol `moduleReference` resolves to from `location`, reporting resolution errors at
+ * `errorNode`. Each name an import or export declaration lists resolves its module specifier again,
+ * with the same result and the same diagnostics: a result that reported nothing is kept for the
+ * specifier and returned to later calls from the same declaration (`sharesSpecifierContext`).
+ */
 export function resolveExternalModule(c, location, moduleReference, moduleNotFoundError, errorNode, isForAugmentation) {
+    // An augmentation merged later can give the resolved module a new merged symbol, so results are
+    // kept only once every augmentation is merged.
+    const shared = c.modulesMerged && errorNode !== undefined && sharesSpecifierContext(location, errorNode);
+    if (shared) {
+        const known = c.moduleResolutions.get(errorNode);
+        if (known !== undefined &&
+            known.moduleReference === moduleReference &&
+            known.moduleNotFoundError === moduleNotFoundError &&
+            known.isForAugmentation === isForAugmentation)
+            return known.symbol;
+    }
+    const reports = c.reports;
+    const symbol = resolveExternalModuleWorker(c, location, moduleReference, moduleNotFoundError, errorNode, isForAugmentation);
+    if (shared && c.reports === reports)
+        c.moduleResolutions.set(errorNode, new ModuleResolution(moduleReference, moduleNotFoundError, isForAugmentation, symbol));
+    return symbol;
+}
+/**
+ * Whether a resolution from `location` with errors at `errorNode` depends on `location` only through
+ * the declaration that `errorNode` is the module specifier of: `location` is that declaration, a
+ * clause or specifier inside it, or the specifier itself. The resolution mode, the emittability of
+ * the import and its resolution-mode attributes then all come from that declaration.
+ */
+function sharesSpecifierContext(location, errorNode) {
+    const declaration = errorNode.parent;
+    if (declaration === undefined ||
+        (declaration.kind !== 273 /* SyntaxKind.ImportDeclaration */ &&
+            declaration.kind !== 346 /* SyntaxKind.JSImportDeclaration */ &&
+            declaration.kind !== 279 /* SyntaxKind.ExportDeclaration */) ||
+        getModuleSpecifier(declaration) !== errorNode)
+        return false;
+    for (let current = location; current !== undefined; current = current.parent)
+        switch (current.kind) {
+            case 273 /* SyntaxKind.ImportDeclaration */:
+            case 346 /* SyntaxKind.JSImportDeclaration */:
+            case 279 /* SyntaxKind.ExportDeclaration */:
+                return current === declaration;
+            case 274 /* SyntaxKind.ImportClause */:
+            case 276 /* SyntaxKind.NamedImports */:
+            case 275 /* SyntaxKind.NamespaceImport */:
+            case 277 /* SyntaxKind.ImportSpecifier */:
+            case 280 /* SyntaxKind.NamedExports */:
+            case 281 /* SyntaxKind.NamespaceExport */:
+            case 282 /* SyntaxKind.ExportSpecifier */:
+                break;
+            default:
+                if (current !== errorNode)
+                    return false;
+        }
+    return false;
+}
+function resolveExternalModuleWorker(c, location, moduleReference, moduleNotFoundError, errorNode, isForAugmentation) {
     if (errorNode !== undefined && moduleReference.startsWith('@types/'))
         c.error(errorNode, 1302 /* Diagnostics.Cannot_import_type_declaration_files_Consider_importing_0_instead_of_1 */, moduleReference.substring(7), moduleReference);
     const ambient = tryFindAmbientModule(c, moduleReference, true);
@@ -490,13 +561,14 @@ function isOnlyImportableAsDefault(c, usage, resolvedModule) {
     const moduleSymbol = resolvedModule ?? resolveExternalModuleName(c, usage, usage, true);
     const targetFile = moduleSymbol !== undefined ? getSourceFileOfModuleSymbol(moduleSymbol) : undefined;
     return (targetFile !== undefined &&
-        (isJsonSourceFile(targetFile) || getDeclarationFileExtension(targetFile.fileName) === '.d.json.ts'));
+        (isJsonSourceFile(targetFile) ||
+            (targetFile.fileName.endsWith('.d.json.ts') && getDeclarationFileExtension(targetFile.fileName) === '.d.json.ts')));
 }
 /** The source file that declares a module: its value declaration, or its first declaration that is not an augmentation. */
 function getSourceFileOfModuleSymbol(symbol) {
     let declaration = symbol.valueDeclaration;
     if (declaration === undefined)
-        for (const d of symbol.declarations)
+        for (const d of getDeclarations(symbol))
             if (!(isAmbientModule(d) && isModuleAugmentationExternal(d)) && !isGlobalScopeAugmentation(d)) {
                 declaration = d;
                 break;
@@ -549,7 +621,7 @@ function createDefaultPropertyWrapperForModule(c, symbol, originalSymbol, anonym
 }
 function cloneTypeAsModuleType(c, symbol, moduleType) {
     const result = c.newSymbol(symbol.flags, symbol.name);
-    result.declarations = symbol.declarations.slice();
+    setDeclarations(result, getDeclarations(symbol).slice());
     result.valueDeclaration = symbol.valueDeclaration;
     if (symbol.members !== undefined)
         result.members = new Map(symbol.members);
@@ -563,7 +635,7 @@ function cloneTypeAsModuleType(c, symbol, moduleType) {
 function getSourceFileDeclaration(symbol) {
     if (symbol === undefined)
         return undefined;
-    for (const d of symbol.declarations)
+    for (const d of getDeclarations(symbol))
         if (d.kind === 307 /* SyntaxKind.SourceFile */)
             return d;
     return undefined;
@@ -605,7 +677,7 @@ function canHaveSyntheticDefault(c, file, moduleSymbol, dontResolveAlias, usage)
         resolveExportByName(c, moduleSymbol, '__esModule', undefined, dontResolveAlias) === undefined);
 }
 function hasSyntacticDefault(symbol) {
-    for (const d of symbol.declarations)
+    for (const d of getDeclarations(symbol))
         if (isSyntacticDefault(d))
             return true;
     return false;
@@ -780,7 +852,7 @@ function reportNonDefaultExport(c, moduleSymbol, node) {
     const exportStar = moduleSymbol.exports?.get("\uFFFEexport" /* InternalSymbolName.ExportStar */);
     if (exportStar === undefined)
         return;
-    for (const d of exportStar.declarations) {
+    for (const d of getDeclarations(exportStar)) {
         const specifier = getModuleSpecifier(d);
         if (d.kind !== 279 /* SyntaxKind.ExportDeclaration */ || specifier === undefined)
             continue;
@@ -896,11 +968,11 @@ function combineValueAndTypeSymbols(c, valueSymbol, typeSymbol) {
     if ((valueSymbol.flags & (788968 /* SymbolFlags.Type */ | 1920 /* SymbolFlags.Namespace */)) !== 0)
         return valueSymbol;
     const result = c.newSymbol(valueSymbol.flags | typeSymbol.flags, valueSymbol.name);
-    const declarations = valueSymbol.declarations.slice();
-    for (const d of typeSymbol.declarations)
+    const declarations = getDeclarations(valueSymbol).slice();
+    for (const d of getDeclarations(typeSymbol))
         if (!declarations.includes(d))
             declarations.push(d);
-    result.declarations = declarations;
+    setDeclarations(result, declarations);
     result.parent = valueSymbol.parent ?? typeSymbol.parent;
     result.valueDeclaration = valueSymbol.valueDeclaration;
     if (typeSymbol.members !== undefined)
@@ -963,8 +1035,8 @@ function reportNonExportedMember(c, name, declarationName, moduleSymbol, moduleN
     const diagnostic = exportedSymbol !== undefined
         ? c.error(name, 626 /* Diagnostics.Module_0_declares_1_locally_but_it_is_exported_as_2 */, moduleName, declarationName, symbolToString(c, exportedSymbol))
         : c.error(name, 625 /* Diagnostics.Module_0_declares_1_locally_but_it_is_not_exported */, moduleName, declarationName);
-    for (let i = 0; i < localSymbol.declarations.length; i++)
-        diagnostic.addRelatedInfo(createDiagnosticForNode(localSymbol.declarations[i], i === 0 ? 860 /* Diagnostics.X_0_is_declared_here */ : 1357 /* Diagnostics.X_and_here */, [declarationName]));
+    for (let i = 0; i < declarationCount(localSymbol); i++)
+        diagnostic.addRelatedInfo(createDiagnosticForNode(declarationAt(localSymbol, i), i === 0 ? 860 /* Diagnostics.X_0_is_declared_here */ : 1357 /* Diagnostics.X_and_here */, [declarationName]));
 }
 function isSameReference(c, s1, s2) {
     return (getMergedSymbol(c, resolveSymbol(c, getMergedSymbol(c, s1))) ===
@@ -1436,7 +1508,7 @@ class ExportCollector {
         if (exportStars !== undefined) {
             const nested = new Map();
             const lookupTable = new Map();
-            for (const node of exportStars.declarations) {
+            for (const node of getDeclarations(exportStars)) {
                 const specifier = node.moduleSpecifier;
                 const resolved = resolveExternalModuleName(this.c, node, specifier, false);
                 const exported = this.visit(resolved, node, isTypeOnly || getIsTypeOnly(node));
@@ -1890,7 +1962,7 @@ function checkExportSpecifier(c, node) {
     if (symbol !== undefined &&
         (symbol === c.undefinedSymbol ||
             symbol === c.globalThisSymbol ||
-            (symbol.declarations.length > 0 && isGlobalSourceFile(getDeclarationContainer(symbol.declarations[0])))))
+            (declarationCount(symbol) > 0 && isGlobalSourceFile(getDeclarationContainer(symbol.declaration)))))
         c.error(exportedName, 795 /* Diagnostics.Cannot_export_0_Only_local_declarations_can_be_exported_from_a_module */, getText(exportedName));
     else
         markExportSpecifierAliasReferenced(c, node, symbol, exportedName);

package/dist/api/compiler/checker-object-literals.d.ts

@@ -1,7 +1,7 @@
 import { type Node, type PropertyAssignment, type ShorthandPropertyAssignment } from './ast.js';
 import { type Checker } from './checker.js';
-import { type Symbol } from './symbol.js';
 import { CheckMode, ObjectFlags, type Type } from './checker-types.js';
+import { type Symbol } from './symbol.js';
 export declare function checkObjectLiteral(c: Checker, node: Node, checkMode: CheckMode): Type;
 export declare function checkPropertyAssignment(c: Checker, node: PropertyAssignment, checkMode: CheckMode): Type;
 export declare function checkShorthandPropertyAssignment(c: Checker, node: ShorthandPropertyAssignment, inDestructuringPattern: boolean, checkMode: CheckMode): Type;

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

@@ -3,10 +3,9 @@ import { checkGrammarObjectLiteralOfExpression } from './checker-grammar.js';
 import { getExpression, getName, getProperties, getSymbol, getText, getType, } from './ast.js';
 import { isAssignmentTarget } from './binder-utilities.js';
 import { createDiagnosticForNode } from './checker.js';
-import { internalSymbolNamePrefix, getSymbolId } from './symbol.js';
 import { emptyIndexInfos, emptySignatures, IndexInfo, } from './checker-types.js';
 import { checkCrossProductUnion, createAnonymousType, getIntersectionType, getUnionType, getUnionTypeEx, isErrorType, mapType, typesOf, } from './checker-type-factory.js';
-import { getDeclarationModifierFlagsFromSymbol, getIndexInfoOfType, getIndexInfosOfType, getIndexTypeOfType, getPropertiesOfType, getPropertyOfType, getReducedType, } from './checker-members.js';
+import { getDeclarationModifierFlagsFromSymbol, getIndexInfoOfType, getIndexInfosOfType, getIndexTypeOfType, getPropertiesOfType, getPropertyOfType, getReducedType, keepPropertiesOnly, scannedLiteralPropertiesLimit, } from './checker-members.js';
 import { symbolToString, typeToString } from './type-printer.js';
 import { getMergedSymbol, getSymbolOfDeclaration } from './checker-symbols.js';
 import { addOptionality, getTypeOfSymbol, removeMissingOrUndefinedType } from './checker-symbol-types.js';
@@ -21,6 +20,7 @@ import { getApparentTypeOfContextualType, getInferenceContext, popContextualType
 import { addIntraExpressionInferenceSite } from './checker-inference.js';
 import { isEmptyObjectType } from './checker-type-factory.js';
 import { getTypeOfExpandoObjectLiteral, isJSObjectLiteral } from './checker-javascript.js';
+import { copyDeclarations, declarationCount, getDeclarations, getSymbolId, internalSymbolNamePrefix, setDeclarations, } from './symbol.js';
 /** Builds the type of the members collected since the last spread. */
 class ObjectLiteralBuilder {
     node;
@@ -63,6 +63,8 @@ class ObjectLiteralBuilder {
             result.objectFlags |= 512 /* ObjectFlags.ObjectLiteralPatternWithComputedProperties */;
         if (this.inDestructuringPattern)
             c.patternForType.set(result, this.node);
+        // A literal of a few properties keeps them as a list; a lookup by name compares their names.
+        keepPropertiesOnly(c, result, this.members, scannedLiteralPropertiesLimit);
         return result;
     }
     reset() {
@@ -147,7 +149,7 @@ export function checkObjectLiteral(c, node, checkMode) {
                 else if (getIndexInfoOfType(c, contextualType, c.stringType) === undefined)
                     c.error(getName(memberDecl), 529 /* Diagnostics.Object_literal_may_only_specify_known_properties_and_0_does_not_exist_in_type_1 */, symbolToString(c, member), typeToString(c, contextualType));
             }
-            prop.declarations = member.declarations;
+            copyDeclarations(prop, member);
             prop.parent = member.parent;
             prop.valueDeclaration = member.valueDeclaration;
             c.symbolTypes.set(id, t);
@@ -243,7 +245,7 @@ function getObjectLiteralIndexInfo(c, isReadonly, properties, keyType) {
             (keyType === c.esSymbolType && isSymbolWithSymbolName(c, prop))) {
             propTypes.push(getTypeOfSymbol(c, prop));
             if (isSymbolWithComputedName(prop))
-                components.push(prop.declarations[0]);
+                components.push(prop.declaration);
         }
     }
     const unionType = propTypes.length !== 0
@@ -252,7 +254,7 @@ function getObjectLiteralIndexInfo(c, isReadonly, properties, keyType) {
     return new IndexInfo(keyType, unionType, isReadonly, undefined, components);
 }
 function getFirstDeclarationName(symbol) {
-    return symbol.declarations.length !== 0 ? getName(symbol.declarations[0]) : undefined;
+    return declarationCount(symbol) !== 0 ? getName(symbol.declaration) : undefined;
 }
 function isSymbolWithSymbolName(c, symbol) {
     if (symbol.name.startsWith(internalSymbolNamePrefix + '@'))
@@ -381,7 +383,7 @@ export function getSpreadType(c, leftIn, rightIn, symbol, objectFlags, readonly)
             : getUnionTypeEx(c, [leftType, rightTypeWithoutUndefined], 2 /* UnionReduction.Subtype */, undefined, undefined));
         c.symbolLeftSpreads.set(id, leftProp);
         c.symbolRightSpreads.set(id, rightProp);
-        result.declarations = leftProp.declarations.concat(rightProp.declarations);
+        setDeclarations(result, getDeclarations(leftProp).concat(getDeclarations(rightProp)));
         c.symbolNameTypes.set(id, c.symbolNameTypes.get(getSymbolId(leftProp)));
         members.set(leftProp.name, result);
     }
@@ -391,6 +393,7 @@ export function getSpreadType(c, leftIn, rightIn, symbol, objectFlags, readonly)
     const spread = createAnonymousType(c, symbol, members, [], [], spreadIndexInfos);
     spread.objectFlags |=
         128 /* ObjectFlags.ObjectLiteral */ | 131072 /* ObjectFlags.ContainsObjectOrArrayLiteral */ | 4194304 /* ObjectFlags.ContainsSpread */ | objectFlags;
+    keepPropertiesOnly(c, spread, members, scannedLiteralPropertiesLimit);
     return spread;
 }
 function getIndexInfoWithReadonly(info, readonly) {
@@ -468,12 +471,13 @@ function tryMergeUnionOfObjectTypeAndEmptyObject(c, t, readonly) {
         const result = c.newSymbolWithCheckFlags(4 /* SymbolFlags.Property */ | 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 : addOptionality(c, getTypeOfSymbol(c, prop), true, true));
-        result.declarations = prop.declarations;
+        copyDeclarations(result, prop);
         c.symbolNameTypes.set(id, c.symbolNameTypes.get(getSymbolId(prop)));
         c.symbolSyntheticOrigins.set(id, prop);
         members.set(prop.name, result);
     }
     const spread = createAnonymousType(c, firstType.symbol, members, [], [], getIndexInfosOfType(c, firstType));
     spread.objectFlags |= 128 /* ObjectFlags.ObjectLiteral */ | 131072 /* ObjectFlags.ContainsObjectOrArrayLiteral */;
+    keepPropertiesOnly(c, spread, members, scannedLiteralPropertiesLimit);
     return spread;
 }

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

@@ -1,6 +1,6 @@
 import { type Node } from './ast.js';
-import { type Symbol } from './symbol.js';
 import { type Checker } from './checker.js';
+import { type Symbol } from './symbol.js';
 /** Checks the overloads of a function or method declaration's local and export symbols. */
 export declare function checkFunctionOrMethodSymbols(c: Checker, node: Node): void;
 /** Checks a function, method or constructor symbol's overloads and implementations, once. */

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

@@ -11,6 +11,7 @@ import { checkComputedPropertyName } from './checker-expressions.js';
 import { hasDynamicName, hasLateBindableName } from './checker-utilities.js';
 import { isSignatureAssignableTo, isTypeIdenticalTo, isTypeRelatedTo } from './relations.js';
 import { getEffectiveDeclarationFlags } from './checker-declarations.js';
+import { getDeclarations } from './symbol.js';
 /** Checks the overloads of a function or method declaration's local and export symbols. */
 export function checkFunctionOrMethodSymbols(c, node) {
     if (hasDynamicName(node) && !hasLateBindableName(c, node))
@@ -52,7 +53,7 @@ class OverloadChecker {
     }
     check() {
         const c = this.c;
-        const declarations = this.symbol.declarations;
+        const declarations = getDeclarations(this.symbol);
         let someNodeFlags = 0 /* ModifierFlags.None */;
         let allNodeFlags = flagsToCheck();
         let someHaveQuestionToken = false;
@@ -149,10 +150,10 @@ class OverloadChecker {
     reportClassMergedWithFunction() {
         const c = this.c;
         const classes = [];
-        for (const d of this.symbol.declarations)
+        for (const d of getDeclarations(this.symbol))
             if (d.kind === 264 /* SyntaxKind.ClassDeclaration */)
                 classes.push(d);
-        for (const d of this.symbol.declarations) {
+        for (const d of getDeclarations(this.symbol)) {
             let message;
             if (d.kind === 264 /* SyntaxKind.ClassDeclaration */)
                 message = 944 /* Diagnostics.Class_declaration_cannot_implement_overload_list_for_0 */;

package/dist/api/compiler/checker-property-access.d.ts

@@ -1,9 +1,9 @@
 import { type Node } from './ast.js';
 import { type Checker } from './checker.js';
 import { type Diagnostic } from './diagnostics.js';
-import { type Symbol } from './symbol.js';
 import { CheckMode, type Type } from './checker-types.js';
 import { AssignmentKind } from './checker-narrowing.js';
+import { type Symbol } from './symbol.js';
 export declare function checkPropertyAccessExpressionOrQualifiedName(c: Checker, node: Node, left: Node, leftType: Type, right: Node, writeOnly: boolean, checkMode?: CheckMode): Type;
 /** A private name used as an expression, as in `#x in obj`; records its declaration. */
 export declare function checkPrivateIdentifierExpression(c: Checker, node: Node): Type;

package/dist/api/compiler/checker-property-access.js

@@ -6,7 +6,6 @@ import { getBody, getExpression, getName, getParameters, getSymbol, getText, get
 import { declarationNameToString, getContainingClass, getSourceFileOfNode, getThisContainer, isAccessExpression, hasSyntacticModifier, isClassLike, isOptionalChain, isPrivateIdentifierClassElementDeclaration, isStatic, skipParentheses, getElementOrPropertyAccessName, isBindableStaticAccessExpression, isBindableStaticNameExpression, } from './binder-utilities.js';
 import { isFunctionLike, isInJSFile } from './ast-utilities.js';
 import { createDiagnosticForNode } from './checker.js';
-import { getSymbolId } from './symbol.js';
 import { everyContainedType, getTargetType, getUnionType, isEmptyObjectType, isErrorType, typesOf, } from './checker-type-factory.js';
 import { getApparentType, getApplicableIndexInfoForName, getDeclarationModifierFlagsFromSymbol, getPropertiesOfType, getPropertiesOfUnionOrIntersectionType, getPropertyOfType, getPropertyOfTypeEx, isConflictingPrivateProperty, isDiscriminantWithNeverType, } from './checker-members.js';
 import { getDeclarationOfAliasSymbol, getParentOfSymbol, getSpellingSuggestionForName, getSymbolOfDeclaration, } from './checker-symbols.js';
@@ -29,6 +28,7 @@ import { checkDeprecatedIndexSignature, checkDeprecatedProperty } from './checke
 import { isSelfTypeAccess, markPropertyAsReferenced } from './checker-unused.js';
 import { getContextualThisParameterType, getFlowTypeOfAccessExpression, getResolvedSymbol, } from './checker-expressions.js';
 import { isJSLiteralType, isThisPropertyAccessInConstructor } from './checker-javascript.js';
+import { getDeclarations, getSymbolId } from './symbol.js';
 export function checkPropertyAccessExpressionOrQualifiedName(c, node, left, leftType, right, writeOnly, checkMode = 0 /* CheckMode.Normal */) {
     const parentSymbol = c.resolvedSymbols.get(left.id);
     const assignmentKind = getAssignmentTargetKind(node);
@@ -409,7 +409,7 @@ function checkPropertyAccessibilityAtLocation(c, location, isSuper, writing, con
     return true;
 }
 function hasClassInstancePropertyDeclaration(symbol) {
-    for (const d of symbol.declarations)
+    for (const d of getDeclarations(symbol))
         if (isClassInstanceProperty(d))
             return true;
     return false;

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

@@ -20,7 +20,7 @@ import { createAnonymousType, getRegularTypeOfLiteralType, isErrorType } from '.
 import { getLiteralTypeFromPropertyName } from './checker-type-operators.js';
 import { getTypeFromThisTypeNode, getTypeFromTypeNode, getUnresolvedSymbolForEntityName, } from './checker-type-nodes.js';
 import { getNodeAtPosition } from './parser.js';
-import { getSymbolId } from './symbol.js';
+import { getSymbolId, setDeclarations } from './symbol.js';
 // ---- Symbols at locations
 /** The symbol a name, keyword or literal at `node` refers to. */
 export function getSymbolAtLocation(c, node) {
@@ -295,7 +295,7 @@ function getApplicableIndexSymbol(c, t, keyType) {
                     declarations.push(other.declaration);
         if (declarations.length !== 0) {
             const symbol = c.newSymbolWithCheckFlags(4 /* SymbolFlags.Property */, "\uFFFEindex" /* InternalSymbolName.Index */, 8388608 /* CheckFlags.IndexSymbol */);
-            symbol.declarations = declarations;
+            setDeclarations(symbol, declarations);
             symbol.valueDeclaration = declarations[0];
             symbol.parent = t.symbol;
             c.symbolTypes.set(getSymbolId(symbol), info.valueType);

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

@@ -1,5 +1,4 @@
 import { type Node } from './ast.js';
-import { InternalSymbolName, type Symbol } from './symbol.js';
 import type { Checker } from './checker.js';
 import { ElementFlags, IndexInfo, type InterfaceType, Signature, SignatureKind, type Type, type TypeMapper, TypePredicate, type TypeReference } from './checker-types.js';
 import { getSymbolOfDeclaration } from './checker-symbols.js';
@@ -7,6 +6,7 @@ import { getClassLikeDeclarationOfSymbol, getConstraintOfTypeParameter } from '.
 import { instantiateTypes } from './instantiation.js';
 import { getIndexInfosOfType } from './checker-members.js';
 import { type TypeComparer } from './relations.js';
+import { InternalSymbolName, type Symbol } from './symbol.js';
 /** Signatures of a symbol's function-like declarations, skipping overload implementations. */
 export declare function getSignaturesOfSymbol(c: Checker, symbol: Symbol | undefined): Signature[];
 export declare function isFunctionLikeNode(node: Node): boolean;

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

@@ -18,13 +18,14 @@ import { isTypeAssignableTo } from './relations.js';
 import { getReturnTypeFromBody, getTypePredicateFromBody } from './checker-functions.js';
 import { checkComputedPropertyName } from './checker-expressions.js';
 import { hasLateBindableIndexSignature } from './checker-utilities.js';
+import { declarationCount, getDeclarations } from './symbol.js';
 // ---- From declarations
 /** Signatures of a symbol's function-like declarations, skipping overload implementations. */
 export function getSignaturesOfSymbol(c, symbol) {
     if (symbol === undefined)
         return [];
     const result = [];
-    const declarations = symbol.declarations;
+    const declarations = getDeclarations(symbol);
     for (let i = 0; i < declarations.length; i++) {
         const decl = declarations[i];
         if (!isFunctionLikeNode(decl))
@@ -236,7 +237,7 @@ export function getReturnTypeFromAnnotation(c, declaration) {
     if (declaration.kind === 178 /* SyntaxKind.GetAccessor */) {
         const symbol = getSymbolOfDeclaration(c, declaration);
         if (symbol !== undefined) {
-            const setter = symbol.declarations.find((d) => d.kind === 179 /* SyntaxKind.SetAccessor */);
+            const setter = getDeclarations(symbol).find((d) => d.kind === 179 /* SyntaxKind.SetAccessor */);
             if (setter !== undefined) {
                 const parameters = getParameters(setter);
                 if (parameters !== undefined) {
@@ -655,7 +656,7 @@ export function getIndexInfosOfIndexSymbol(c, indexSymbol, siblingSymbols) {
     let readonlyNumber = true;
     let readonlySymbol = true;
     const propertySymbols = [];
-    for (const declaration of indexSymbol.declarations) {
+    for (const declaration of getDeclarations(indexSymbol)) {
         if (declaration.kind === 182 /* SyntaxKind.IndexSignature */) {
             const parameters = getParameters(declaration)?.nodes ?? [];
             const returnTypeNode = getType(declaration);
@@ -722,7 +723,7 @@ import { getContextualTypeEx } from './checker-contextual.js';
 function isSymbolWithSymbolName(c, symbol) {
     if (symbol.name.startsWith('\ufffe@'))
         return true;
-    const name = symbol.declarations.length !== 0 ? getName(symbol.declarations[0]) : undefined;
+    const name = declarationCount(symbol) !== 0 ? getName(symbol.declaration) : undefined;
     return (name !== undefined &&
         name.kind === 168 /* SyntaxKind.ComputedPropertyName */ &&
         isTypeAssignableToKind(c, checkComputedPropertyName(c, name), 512 /* TypeFlags.ESSymbol */));
@@ -731,7 +732,7 @@ function isSymbolWithSymbolName(c, symbol) {
 function isSymbolWithNumericName(c, symbol) {
     if (isNumericLiteralName(symbol.name))
         return true;
-    const name = symbol.declarations.length !== 0 ? getName(symbol.declarations[0]) : undefined;
+    const name = declarationCount(symbol) !== 0 ? getName(symbol.declaration) : undefined;
     if (name === undefined)
         return false;
     if (name.kind === 168 /* SyntaxKind.ComputedPropertyName */)
@@ -750,7 +751,7 @@ function getObjectLiteralIndexInfo(c, isReadonly, properties, keyType) {
             (keyType === c.esSymbolType && isSymbolWithSymbolName(c, prop))) {
             propTypes.push(getTypeOfSymbol(c, prop));
             if (isSymbolWithComputedName(prop))
-                components.push(prop.declarations[0]);
+                components.push(prop.declaration);
         }
     }
     const unionType = propTypes.length !== 0
@@ -759,9 +760,9 @@ function getObjectLiteralIndexInfo(c, isReadonly, properties, keyType) {
     return new IndexInfo(keyType, unionType, isReadonly, undefined, components);
 }
 function isSymbolWithComputedName(symbol) {
-    if (symbol.declarations.length === 0)
+    if (declarationCount(symbol) === 0)
         return false;
-    const name = getName(symbol.declarations[0]);
+    const name = getName(symbol.declaration);
     return name !== undefined && name.kind === 168 /* SyntaxKind.ComputedPropertyName */;
 }
 export { getIndexInfosOfType, instantiateTypes, getConstraintOfTypeParameter, getClassLikeDeclarationOfSymbol, getSymbolOfDeclaration, };

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

@@ -1,11 +1,11 @@
 import { CheckMode } from './checker-types.js';
-import { type Node, type SourceFile } from './ast.js';
+import { type Node } from './ast.js';
 import { hasStaticModifier } from './binder-utilities.js';
-import { type Symbol } from './symbol.js';
 import { type Checker } from './checker.js';
 import { type Type, TypeFlags, type UnionType } from './checker-types.js';
 import { filterType } from './checker-type-factory.js';
 import { getDeclarationOfAliasSymbol } from './checker-symbols.js';
+import { type Symbol } from './symbol.js';
 export declare function getTypeOfSymbol(c: Checker, symbol: Symbol): Type;
 export declare function getTypeOfParameter(c: Checker, symbol: Symbol): Type;
 export declare function getNonMissingTypeOfSymbol(c: Checker, symbol: Symbol): Type;
@@ -34,22 +34,6 @@ export declare const enum WideningKind {
 export declare function reportErrorsFromWidening(c: Checker, declaration: Node, t: Type, wideningKind: WideningKind): void;
 export declare function reportImplicitAny(c: Checker, declaration: Node, t: Type, wideningKind?: WideningKind): void;
 export declare function getWidenedType(c: Checker, t: Type): Type;
-/**
- * By name, the first property of the unions of `file`'s object literals that leave the name missing.
- * Without a checker, as on a parse thread, array literals are taken to have the global Array type, and
- * the result is undefined where an enum the scan can't resolve decides which literals subtype reduction
- * leaves out (`enumKeyOfMemberAccess`); the checker then scans the file itself.
- */
-export declare function scanSiblingProperties(file: SourceFile, c: Checker | undefined): Map<string, Node> | undefined;
-/** The first property of each name among the files of one of tsgo's checkers, scanned in order. */
-export declare class SlotSiblingProperties {
-    readonly members: Map<string, Node>;
-    /** The index of the file of each name's property. */
-    readonly fileIndexes: Map<string, number>;
-    /** The index of the next file of the checker to scan. */
-    next: number;
-    constructor(first: number);
-}
 export declare function addOptionality(c: Checker, t: Type, isProperty: boolean, isOptional: boolean): Type;
 export declare function getOptionalType(c: Checker, t: Type, isProperty: boolean): Type;
 export declare function addOptionalTypeMarker(c: Checker, t: Type): Type;