tsc-ts 0.0.5 → 0.0.6

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

@@ -1,6 +1,5 @@
 import type { Node } from './ast.js';
 import { ModifierFlags } from './ast.js';
-import { type Symbol, type SymbolTable } from './symbol.js';
 import type { Checker } from './checker.js';
 import { IndexInfo, type InterfaceType, MemberNames, ObjectFlags, type Signature, SignatureKind, type StructuredType, type Type, type TypeMapper, type UnionOrIntersectionType, PendingMembers } from './checker-types.js';
 import { getUnionTypeEx, mapType } from './checker-type-factory.js';
@@ -8,6 +7,7 @@ import { getLateBoundSymbol, getSymbolOfDeclaration } from './checker-symbols.js
 import { instantiateTypes } from './instantiation.js';
 import { type RecursionId } from './relations.js';
 import { createSignatureInstantiation, getReturnTypeOfSignature } from './checker-signatures.js';
+import { type Symbol, type SymbolTable } from './symbol.js';
 /**
  * `t` with its members resolved. The test is small enough to inline into callers, so a resolved
  * type (almost every call) costs no call; the resolution itself is out of line.
@@ -97,11 +97,13 @@ export declare class PropertyMembers extends PendingMembers {
     materializeTable(t: StructuredType): void;
     get(name: string): Symbol | undefined;
 }
+/** The most properties of an object literal's table that `keepPropertiesOnly` drops: literals are looked up often. */
+export declare const scannedLiteralPropertiesLimit = 4;
 /**
  * After `setStructuredTypeMembers(c, t, members, ...)`: drops `members` where it holds only the
- * type's properties, at most `scannedPropertiesLimit` of them (`PropertyMembers`).
+ * type's properties, at most `limit` of them (`PropertyMembers`).
  */
-export declare function keepPropertiesOnly(c: Checker, t: StructuredType, members: SymbolTable): void;
+export declare function keepPropertiesOnly(c: Checker, t: StructuredType, members: SymbolTable, limit?: number): void;
 /** `t.members?.get(name)` of a type whose members are resolved, without building a pending table. */
 export declare function getResolvedMember(t: StructuredType, name: string): Symbol | undefined;
 /** `t.properties.length !== 0` of a type whose members are resolved, without building a pending table. */

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

@@ -1,7 +1,6 @@
 import { getCombinedModifierFlags, getDeclarationOfKind } from './binder-utilities.js';
 import { getSymbol, getName } from './ast.js';
-import { getSymbolId } from './symbol.js';
-import { cachedTypeKey, CompositeSignature, IndexInfo, MemberNames, emptyIndexInfos, emptySignatures, emptySymbols, emptyTypes, newTypeMapper, prependTypeMapping, PendingMembers, } from './checker-types.js';
+import { cachedTypeKey, CompositeSignature, IndexInfo, MemberNames, unionOrIntersectionMembers, emptyIndexInfos, emptySignatures, emptySymbols, emptyTypes, newThisArgumentTypeMapper, newTypeMapper, prependTypeMapping, PendingMembers, } from './checker-types.js';
 import { createArrayTypeEx, createTupleTypeEx, createTypeReference, everyType, getElementTypes, getIntersectionType, getStringLiteralType, getTemplateLiteralType, getTypeArguments, getUnionOrIntersectionType, getUnionType, getUnionTypeEx, isArrayOrTupleType, isErrorType, isGenericTupleType, isLiteralType, isPatternLiteralType, isReadonlyArrayType, isTupleType, mapType, setStructuredTypeMembers, someType, tupleTargetOf, typesOf, } from './checker-type-factory.js';
 import { getRestTypeOfTupleType, mappedTypeTarget } from './checker-type-operators.js';
 import { isAmbientModule } from './ast-utilities.js';
@@ -17,7 +16,8 @@ import { cloneSignature, createSignatureInstantiation, getDefaultConstructSignat
 import { getConstraintFromConditionalType, getHomomorphicTypeVariable, getIndexForMappedType, getIndexedAccessTypeOrUndefined, getModifiersTypeFromMappedType, getNameTypeFromMappedType, getSimplifiedType, getStringMappingType, getSubstitutionIntersection, isGenericMappedType, isMappedTypeGenericIndexedAccess, isMappedTypeWithKeyofConstraintDeclaration, resolveMappedTypeMembers, resolveReverseMappedTypeMembers, substituteIndexedMappedType, } from './checker-type-operators.js';
 import { getGlobalBigIntType, getGlobalESSymbolType } from './checker-globals.js';
 import { isLateBoundName, isNumericLiteralName } from './checker-utilities.js';
-import { lazyObjectFlags, sideOf } from './side-state.js';
+import { lazyObjectFlags, sideOf, sideOfIfAny } from './side-state.js';
+import { copyDeclarations, declarationCount, getDeclarations, getSymbolId, setDeclarations, } from './symbol.js';
 // ---- Resolution
 /**
  * `t` with its members resolved. The test is small enough to inline into callers, so a resolved
@@ -37,11 +37,18 @@ export function resolveStructuredTypeMembers(c, t) {
  * `t` writes them there; `t` keeps its identity and is never written.
  */
 export function membersHolder(c, t) {
-    return sideOf(c, t);
+    const side = sideOf(c, t);
+    if ((side.flags & 402653184 /* TypeFlags.UnionOrIntersection */) !== 0)
+        return unionOrIntersectionMembers(side);
+    return side;
 }
 /** The `objectFlags` of `t` that resolving its members sets (MembersResolved, UnresolvedMembers). */
 export function memberResolutionFlags(c, t) {
-    return lazyObjectFlags(c, t);
+    if ((t.flags & 402653184 /* TypeFlags.UnionOrIntersection */) === 0)
+        return lazyObjectFlags(c, t);
+    const side = sideOfIfAny(c, t);
+    const members = side !== undefined ? side.membersOf : undefined;
+    return members !== undefined ? members.objectFlags : 0 /* ObjectFlags.None */;
 }
 function resolveMembersOfType(c, t) {
     if ((t.flags & 1048576 /* TypeFlags.Object */) !== 0) {
@@ -49,7 +56,7 @@ function resolveMembersOfType(c, t) {
         if ((objectFlags & 4 /* ObjectFlags.Reference */) !== 0)
             resolveTypeReferenceMembers(c, t);
         else if ((objectFlags & 3 /* ObjectFlags.ClassOrInterface */) !== 0)
-            resolveObjectTypeMembers(c, membersHolder(c, t), t, emptyTypes, emptyTypes);
+            resolveObjectTypeMembers(c, membersHolder(c, t), t, emptyTypes, emptyTypes, undefined);
         else if ((objectFlags & 1024 /* ObjectFlags.ReverseMapped */) !== 0)
             resolveReverseMappedTypeMembers(c, t);
         else if ((objectFlags & 16 /* ObjectFlags.Anonymous */) !== 0)
@@ -66,26 +73,25 @@ function resolveTypeReferenceMembers(c, t) {
     const source = t.target;
     const typeParameters = source.allTypeParameters;
     const typeArguments = getTypeArguments(c, t);
-    let padded = typeArguments;
-    if (typeArguments.length === typeParameters.length - 1) {
-        // The reference itself is the `this` type argument.
-        padded = [];
-        for (const typeArgument of typeArguments)
-            padded.push(typeArgument);
-        padded.push(t);
-    }
-    resolveObjectTypeMembers(c, membersHolder(c, t), source, typeParameters, padded);
-}
-function sameTypes(a, b) {
-    if (a.length !== b.length)
+    // With one type argument fewer than parameters, the reference itself is the `this` type argument.
+    const thisArgument = typeArguments.length === typeParameters.length - 1 ? t : undefined;
+    resolveObjectTypeMembers(c, membersHolder(c, t), source, typeParameters, typeArguments, thisArgument);
+}
+/** Whether `b`, followed by `last` where given, is the list `a`. */
+function sameTypes(a, b, last) {
+    const count = b.length;
+    if (a.length !== (last !== undefined ? count + 1 : count))
         return false;
-    for (let i = 0; i < a.length; i++)
+    for (let i = 0; i < count; i++)
         if (a[i] !== b[i])
             return false;
-    return true;
+    return last === undefined || a[count] === last;
 }
-/** Resolves the members of an instantiation of `source` into `t`, the holder of its members. */
-function resolveObjectTypeMembers(c, t, source, typeParameters, typeArguments) {
+/**
+ * Resolves the members of an instantiation of `source` into `t`, the holder of its members: with
+ * `typeArguments` for its type parameters, followed by `thisArgument` where given.
+ */
+function resolveObjectTypeMembers(c, t, source, typeParameters, typeArguments, thisArgument) {
     const declared = resolveDeclaredMembers(c, source);
     let mapper;
     let members;
@@ -95,7 +101,7 @@ function resolveObjectTypeMembers(c, t, source, typeParameters, typeArguments) {
     let instantiated = false;
     // The member symbols of an instantiation are instantiated on demand (PendingInstantiatedMembers).
     let pending;
-    if (sameTypes(typeParameters, typeArguments)) {
+    if (sameTypes(typeParameters, typeArguments, thisArgument)) {
         members = declared.declaredMembers;
         callSignatures = declared.declaredCallSignatures;
         constructSignatures = declared.declaredConstructSignatures;
@@ -103,7 +109,10 @@ function resolveObjectTypeMembers(c, t, source, typeParameters, typeArguments) {
     }
     else {
         instantiated = true;
-        mapper = newTypeMapper(typeParameters, typeArguments);
+        mapper =
+            thisArgument !== undefined
+                ? newThisArgumentTypeMapper(typeParameters, typeArguments, thisArgument)
+                : newTypeMapper(typeParameters, typeArguments);
         pending = pendingInstantiatedTable(c, source, mapper);
         members = pending === undefined ? instantiateSymbolTable(c, declared.declaredMembers, mapper) : undefined;
         callSignatures = instantiateSignatures(c, declared.declaredCallSignatures, mapper);
@@ -111,18 +120,19 @@ function resolveObjectTypeMembers(c, t, source, typeParameters, typeArguments) {
         indexInfos = instantiateIndexInfos(c, declared.declaredIndexInfos, mapper);
     }
     const baseTypes = getBaseTypes(c, source);
+    // The last type argument, the `this` type argument where the reference has one.
+    const lastArgument = thisArgument ?? (typeArguments.length !== 0 ? typeArguments[typeArguments.length - 1] : undefined);
     if (pending !== undefined) {
-        resolvePendingObjectTypeMembers(c, t, pending, baseTypes, mapper, typeArguments, callSignatures, constructSignatures, indexInfos);
+        resolvePendingObjectTypeMembers(c, t, pending, baseTypes, mapper, lastArgument, callSignatures, constructSignatures, indexInfos);
         return;
     }
     if (baseTypes.length !== 0) {
         members = !instantiated || members === undefined ? new Map(members ?? []) : members;
         setStructuredTypeMembers(c, t, members, callSignatures, constructSignatures, indexInfos);
-        const thisArgument = typeArguments.length !== 0 ? typeArguments[typeArguments.length - 1] : undefined;
         t.objectFlags |= 536870912 /* ObjectFlags.UnresolvedMembers */;
         for (const baseType of baseTypes) {
-            const instantiatedBaseType = thisArgument !== undefined
-                ? getTypeWithThisArgument(c, instantiateType(c, baseType, mapper), thisArgument, false)
+            const instantiatedBaseType = lastArgument !== undefined
+                ? getTypeWithThisArgument(c, instantiateType(c, baseType, mapper), lastArgument, false)
                 : baseType;
             addInheritedMembers(members, getPropertiesOfType(c, instantiatedBaseType));
             // A base without signatures adds none: no copy of the list then.
@@ -397,14 +407,16 @@ export class PropertyMembers extends PendingMembers {
 }
 /** The most properties of a table that `keepPropertiesOnly` drops: a lookup compares that many names at most. */
 const scannedPropertiesLimit = 8;
+/** The most properties of an object literal's table that `keepPropertiesOnly` drops: literals are looked up often. */
+export const scannedLiteralPropertiesLimit = 4;
 /**
  * After `setStructuredTypeMembers(c, t, members, ...)`: drops `members` where it holds only the
- * type's properties, at most `scannedPropertiesLimit` of them (`PropertyMembers`).
+ * type's properties, at most `limit` of them (`PropertyMembers`).
  */
-export function keepPropertiesOnly(c, t, members) {
+export function keepPropertiesOnly(c, t, members, limit = scannedPropertiesLimit) {
     const resolved = membersHolder(c, t);
     const properties = resolved.propertiesValue;
-    if (members.size === 0 || members.size > scannedPropertiesLimit || properties.length !== members.size)
+    if (members.size === 0 || members.size > limit || properties.length !== members.size)
         return;
     resolved.membersValue = undefined;
     resolved.pendingMembers = new PropertyMembers(properties, undefined);
@@ -616,13 +628,12 @@ export function resolvedPropertiesAreOptional(t) {
     return true;
 }
 /** resolveObjectTypeMembers for an instantiation whose member symbols are instantiated on demand. */
-function resolvePendingObjectTypeMembers(c, t, pending, baseTypes, mapper, typeArguments, callSignatures, constructSignatures, indexInfos) {
+function resolvePendingObjectTypeMembers(c, t, pending, baseTypes, mapper, thisArgument, callSignatures, constructSignatures, indexInfos) {
     setPendingStructuredTypeMembers(c, t, pending, callSignatures, constructSignatures, indexInfos);
     if (baseTypes.length === 0)
         return;
     pending.hasBases = true;
     pending.resolving = true;
-    const thisArgument = typeArguments.length !== 0 ? typeArguments[typeArguments.length - 1] : undefined;
     t.objectFlags |= 536870912 /* ObjectFlags.UnresolvedMembers */;
     for (const baseType of baseTypes) {
         const instantiatedBaseType = thisArgument !== undefined
@@ -786,7 +797,7 @@ function resolveAnonymousTypeMembers(c, t) {
         for (const p of members.values()) {
             if ((p.flags & 418 /* SymbolFlags.BlockScoped */) !== 0)
                 continue;
-            if ((p.flags & 512 /* SymbolFlags.ValueModule */) !== 0 && isOnlyAmbientModuleDeclarations(p.declarations))
+            if ((p.flags & 512 /* SymbolFlags.ValueModule */) !== 0 && isOnlyAmbientModuleDeclarations(getDeclarations(p)))
                 continue;
             varsOnly.set(p.name, p);
         }
@@ -1217,8 +1228,10 @@ export function getPropertiesOfObjectType(c, t) {
     return (t.flags & 1048576 /* TypeFlags.Object */) !== 0 ? resolveStructuredTypeMembers(c, t).properties : emptySymbols;
 }
 export function getPropertiesOfUnionOrIntersectionType(c, t) {
-    const side = sideOf(c, t);
-    if (side.resolvedProperties === undefined) {
+    const known = sideOf(c, t).membersOf;
+    if (known !== undefined && known.resolvedProperties !== undefined)
+        return known.resolvedProperties;
+    {
         const checked = new Set();
         const props = [];
         for (const current of t.types) {
@@ -1234,9 +1247,11 @@ export function getPropertiesOfUnionOrIntersectionType(c, t) {
             if ((t.flags & 134217728 /* TypeFlags.Union */) !== 0 && getIndexInfosOfType(c, current).length === 0)
                 break;
         }
+        // Resolving the properties may have created the holder.
+        const side = unionOrIntersectionMembers(sideOf(c, t));
         side.resolvedProperties = props;
+        return props;
     }
-    return side.resolvedProperties;
 }
 export function getPropertyOfType(c, t, name) {
     return getPropertyOfTypeEx(c, t, name, false, false);
@@ -1316,18 +1331,24 @@ export function getPropertyOfUnionOrIntersectionType(c, t, name, skipObjectFunct
  * property twice.
  */
 export function getUnionOrIntersectionProperty(c, t, name, skipObjectFunctionPropertyAugment) {
-    const side = sideOf(c, t);
-    let cache = skipObjectFunctionPropertyAugment ? side.propertyCacheWithoutFunctionPropertyAugment : side.propertyCache;
-    const cached = cache?.get(name);
-    if (cached !== undefined)
-        return cached;
-    if (!skipObjectFunctionPropertyAugment) {
-        const withoutAugment = side.propertyCacheWithoutFunctionPropertyAugment?.get(name);
-        if (withoutAugment !== undefined && (withoutAugment.checkFlags & 48 /* CheckFlags.Partial */) === 0)
-            return withoutAugment;
+    const known = sideOf(c, t).membersOf;
+    if (known !== undefined) {
+        const cached = (skipObjectFunctionPropertyAugment ? known.propertyCacheWithoutFunctionPropertyAugment : known.propertyCache)?.get(name);
+        if (cached !== undefined)
+            return cached;
+        if (!skipObjectFunctionPropertyAugment) {
+            const withoutAugment = known.propertyCacheWithoutFunctionPropertyAugment?.get(name);
+            if (withoutAugment !== undefined && (withoutAugment.checkFlags & 48 /* CheckFlags.Partial */) === 0)
+                return withoutAugment;
+        }
     }
     const prop = createUnionOrIntersectionProperty(c, t, name, skipObjectFunctionPropertyAugment);
     if (prop !== undefined) {
+        // Creating the property may have created the holder and its caches.
+        const side = unionOrIntersectionMembers(sideOf(c, t));
+        let cache = skipObjectFunctionPropertyAugment
+            ? side.propertyCacheWithoutFunctionPropertyAugment
+            : side.propertyCache;
         if (cache === undefined) {
             cache = new Map();
             if (skipObjectFunctionPropertyAugment)
@@ -1483,7 +1504,7 @@ export function createUnionOrIntersectionProperty(c, containingType, name, skipO
             firstValueDeclaration = prop.valueDeclaration;
         else if (prop.valueDeclaration !== undefined && prop.valueDeclaration !== firstValueDeclaration)
             hasNonUniformValueDeclaration = true;
-        for (const d of prop.declarations)
+        for (const d of getDeclarations(prop))
             declarations.push(d);
         const t = getTypeOfSymbol(c, prop);
         if (firstType === undefined) {
@@ -1507,7 +1528,7 @@ export function createUnionOrIntersectionProperty(c, containingType, name, skipO
     for (const t of indexTypes)
         propTypes.push(t);
     const result = c.newSymbolWithCheckFlags(propFlags | optionalFlag, name, checkFlags | syntheticFlag);
-    result.declarations = declarations;
+    setDeclarations(result, declarations);
     if (!hasNonUniformValueDeclaration && firstValueDeclaration !== undefined) {
         result.valueDeclaration = firstValueDeclaration;
         result.parent = getSymbol(firstValueDeclaration)?.parent;
@@ -1541,14 +1562,14 @@ export function isPrototypeProperty(symbol) {
 function hasCommonDeclaration(symbols) {
     let common;
     for (const symbol of symbols) {
-        if (symbol.declarations.length === 0)
+        if (declarationCount(symbol) === 0)
             return false;
         if (common === undefined) {
-            common = new Set(symbol.declarations);
+            common = new Set(getDeclarations(symbol));
             continue;
         }
         const next = new Set();
-        for (const d of symbol.declarations)
+        for (const d of getDeclarations(symbol))
             if (common.has(d))
                 next.add(d);
         if (next.size === 0)
@@ -1559,7 +1580,7 @@ function hasCommonDeclaration(symbols) {
 }
 export function createSymbolWithType(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);
@@ -1819,7 +1840,8 @@ export function getReducedType(c, t) {
  * private, are combined, and the costliest constituent's properties are only looked up by name.
  */
 function hasNeverReducedProperty(c, t) {
-    const resolved = sideOf(c, t).resolvedProperties;
+    const members = sideOf(c, t).membersOf;
+    const resolved = members !== undefined ? members.resolvedProperties : undefined;
     if (resolved !== undefined) {
         for (const p of resolved)
             if (isNeverReducedProperty(c, p))

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

@@ -1,9 +1,9 @@
 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;

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) {
@@ -496,7 +496,7 @@ function isOnlyImportableAsDefault(c, usage, resolvedModule) {
 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 +549,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 +563,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 +605,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 +780,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 +896,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 +963,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 +1436,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 +1890,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);