tsc-ts 0.0.5 → 0.0.6

package/src/compiler/checker-members.ts

@@ -4,7 +4,6 @@ import type { Node } from './ast.js';
 import { getCombinedModifierFlags, getDeclarationOfKind } from './binder-utilities.js';
 import { Diagnostics } from './diagnostics.js';
 import { ModifierFlags, getSymbol, MappedTypeNode, getName } from './ast.js';
-import { CheckFlags, InternalSymbolName, type Symbol, SymbolFlags, type SymbolTable, getSymbolId } from './symbol.js';
 import { SyntaxKind } from './syntax-kind.js';
 import type { Checker } from './checker.js';
 import {
@@ -34,11 +33,13 @@ import {
   type TypeParameter,
   type TypeReference,
   type UnionOrIntersectionType,
+  unionOrIntersectionMembers,
   type UnionType,
   emptyIndexInfos,
   emptySignatures,
   emptySymbols,
   emptyTypes,
+  newThisArgumentTypeMapper,
   newTypeMapper,
   prependTypeMapping,
   LiteralType,
@@ -151,7 +152,19 @@ import {
 } 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 {
+  CheckFlags,
+  copyDeclarations,
+  declarationCount,
+  getDeclarations,
+  getSymbolId,
+  InternalSymbolName,
+  setDeclarations,
+  type Symbol,
+  SymbolFlags,
+  type SymbolTable,
+} from './symbol.js';
 
 // ---- Resolution
 
@@ -172,12 +185,18 @@ export function resolveStructuredTypeMembers(c: Checker, t: Type): StructuredTyp
  * `t` writes them there; `t` keeps its identity and is never written.
  */
 export function membersHolder(c: Checker, t: Type): StructuredType {
-  return sideOf(c, t as StructuredType);
+  const side = sideOf(c, t);
+  if ((side.flags & TypeFlags.UnionOrIntersection) !== 0)
+    return unionOrIntersectionMembers(side as UnionOrIntersectionType);
+  return side as StructuredType;
 }
 
 /** The `objectFlags` of `t` that resolving its members sets (MembersResolved, UnresolvedMembers). */
 export function memberResolutionFlags(c: Checker, t: Type): ObjectFlags {
-  return lazyObjectFlags(c, t);
+  if ((t.flags & TypeFlags.UnionOrIntersection) === 0) return lazyObjectFlags(c, t);
+  const side = sideOfIfAny(c, t) as UnionOrIntersectionType | undefined;
+  const members = side !== undefined ? side.membersOf : undefined;
+  return members !== undefined ? members.objectFlags : ObjectFlags.None;
 }
 
 function resolveMembersOfType(c: Checker, t: Type): void {
@@ -185,7 +204,7 @@ function resolveMembersOfType(c: Checker, t: Type): void {
     const objectFlags = t.objectFlags;
     if ((objectFlags & ObjectFlags.Reference) !== 0) resolveTypeReferenceMembers(c, t as TypeReference);
     else if ((objectFlags & ObjectFlags.ClassOrInterface) !== 0)
-      resolveObjectTypeMembers(c, membersHolder(c, t), t as InterfaceType, emptyTypes, emptyTypes);
+      resolveObjectTypeMembers(c, membersHolder(c, t), t as InterfaceType, emptyTypes, emptyTypes, undefined);
     else if ((objectFlags & ObjectFlags.ReverseMapped) !== 0) resolveReverseMappedTypeMembers(c, t);
     else if ((objectFlags & ObjectFlags.Anonymous) !== 0) resolveAnonymousTypeMembers(c, t as ObjectType);
     else if ((objectFlags & ObjectFlags.Mapped) !== 0) resolveMappedTypeMembers(c, t as MappedType);
@@ -197,29 +216,30 @@ function resolveTypeReferenceMembers(c: Checker, t: TypeReference): void {
   const source = t.target as InterfaceType;
   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 as Type);
-  }
-  resolveObjectTypeMembers(c, membersHolder(c, t), source, typeParameters, padded);
+  // With one type argument fewer than parameters, the reference itself is the `this` type argument.
+  const thisArgument = typeArguments.length === typeParameters.length - 1 ? (t as Type) : undefined;
+  resolveObjectTypeMembers(c, membersHolder(c, t), source, typeParameters, typeArguments, thisArgument);
 }
 
-function sameTypes(a: readonly Type[], b: readonly Type[]): boolean {
-  if (a.length !== b.length) return false;
-  for (let i = 0; i < a.length; i++) if (a[i]! !== b[i]!) return false;
-  return true;
+/** Whether `b`, followed by `last` where given, is the list `a`. */
+function sameTypes(a: readonly Type[], b: readonly Type[], last: Type | undefined): boolean {
+  const count = b.length;
+  if (a.length !== (last !== undefined ? count + 1 : count)) return false;
+  for (let i = 0; i < count; i++) if (a[i]! !== b[i]!) return false;
+  return last === undefined || a[count]! === last;
 }
 
-/** Resolves the members of an instantiation of `source` into `t`, the holder of its members. */
+/**
+ * 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: Checker,
   t: StructuredType,
   source: InterfaceType,
   typeParameters: Type[],
   typeArguments: Type[],
+  thisArgument: Type | undefined,
 ): void {
   const declared = resolveDeclaredMembers(c, source);
   let mapper: TypeMapper | undefined;
@@ -230,14 +250,17 @@ function resolveObjectTypeMembers(
   let instantiated = false;
   // The member symbols of an instantiation are instantiated on demand (PendingInstantiatedMembers).
   let pending: PendingInstantiatedMembers | undefined;
-  if (sameTypes(typeParameters, typeArguments)) {
+  if (sameTypes(typeParameters, typeArguments, thisArgument)) {
     members = declared.declaredMembers;
     callSignatures = declared.declaredCallSignatures;
     constructSignatures = declared.declaredConstructSignatures;
     indexInfos = declared.declaredIndexInfos;
   } 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);
@@ -245,6 +268,9 @@ function resolveObjectTypeMembers(
     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,
@@ -252,7 +278,7 @@ function resolveObjectTypeMembers(
       pending,
       baseTypes,
       mapper!,
-      typeArguments,
+      lastArgument,
       callSignatures,
       constructSignatures,
       indexInfos,
@@ -262,12 +288,11 @@ function resolveObjectTypeMembers(
   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 |= ObjectFlags.UnresolvedMembers;
     for (const baseType of baseTypes) {
       const instantiatedBaseType =
-        thisArgument !== undefined
-          ? getTypeWithThisArgument(c, instantiateType(c, baseType, mapper), thisArgument, false)
+        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.
@@ -576,14 +601,22 @@ 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: Checker, t: StructuredType, members: SymbolTable): void {
+export function keepPropertiesOnly(
+  c: Checker,
+  t: StructuredType,
+  members: SymbolTable,
+  limit: number = scannedPropertiesLimit,
+): void {
   const resolved = membersHolder(c, t);
   const properties = resolved.propertiesValue;
-  if (members.size === 0 || members.size > scannedPropertiesLimit || properties.length !== members.size) return;
+  if (members.size === 0 || members.size > limit || properties.length !== members.size) return;
   resolved.membersValue = undefined;
   resolved.pendingMembers = new PropertyMembers(properties, undefined);
 }
@@ -807,7 +840,7 @@ function resolvePendingObjectTypeMembers(
   pending: PendingInstantiatedMembers,
   baseTypes: Type[],
   mapper: TypeMapper,
-  typeArguments: Type[],
+  thisArgument: Type | undefined,
   callSignatures: Signature[],
   constructSignatures: Signature[],
   indexInfos: IndexInfo[],
@@ -816,7 +849,6 @@ function resolvePendingObjectTypeMembers(
   if (baseTypes.length === 0) return;
   pending.hasBases = true;
   pending.resolving = true;
-  const thisArgument = typeArguments.length !== 0 ? typeArguments[typeArguments.length - 1]! : undefined;
   t.objectFlags |= ObjectFlags.UnresolvedMembers;
   for (const baseType of baseTypes) {
     const instantiatedBaseType =
@@ -999,7 +1031,7 @@ function resolveAnonymousTypeMembers(c: Checker, t: ObjectType): void {
     const varsOnly = new Map<string, Symbol>();
     for (const p of members.values()) {
       if ((p.flags & SymbolFlags.BlockScoped) !== 0) continue;
-      if ((p.flags & SymbolFlags.ValueModule) !== 0 && isOnlyAmbientModuleDeclarations(p.declarations)) continue;
+      if ((p.flags & SymbolFlags.ValueModule) !== 0 && isOnlyAmbientModuleDeclarations(getDeclarations(p))) continue;
       varsOnly.set(p.name, p);
     }
     members = varsOnly;
@@ -1494,8 +1526,9 @@ export function getPropertiesOfObjectType(c: Checker, t: Type): Symbol[] {
 }
 
 export function getPropertiesOfUnionOrIntersectionType(c: Checker, t: UnionOrIntersectionType): Symbol[] {
-  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<string>();
     const props: Symbol[] = [];
     for (const current of t.types) {
@@ -1513,9 +1546,11 @@ export function getPropertiesOfUnionOrIntersectionType(c: Checker, t: UnionOrInt
       // Union properties are in every constituent: the first without index signatures suffices.
       if ((t.flags & 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: Checker, t: Type, name: string): Symbol | undefined {
@@ -1614,16 +1649,24 @@ export function getUnionOrIntersectionProperty(
   name: string,
   skipObjectFunctionPropertyAugment: boolean,
 ): Symbol | undefined {
-  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 & 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 & 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<string, Symbol>();
       if (skipObjectFunctionPropertyAugment) side.propertyCacheWithoutFunctionPropertyAugment = cache;
@@ -1765,7 +1808,7 @@ export function createUnionOrIntersectionProperty(
     if (firstValueDeclaration === undefined) firstValueDeclaration = prop.valueDeclaration;
     else if (prop.valueDeclaration !== undefined && prop.valueDeclaration !== firstValueDeclaration)
       hasNonUniformValueDeclaration = true;
-    for (const d of prop.declarations) declarations.push(d);
+    for (const d of getDeclarations(prop)) declarations.push(d);
     const t = getTypeOfSymbol(c, prop);
     if (firstType === undefined) {
       firstType = t;
@@ -1783,7 +1826,7 @@ export function createUnionOrIntersectionProperty(
   }
   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;
@@ -1821,13 +1864,13 @@ export function isPrototypeProperty(symbol: Symbol): boolean {
 function hasCommonDeclaration(symbols: Symbol[]): boolean {
   let common: Set<Node> | undefined;
   for (const symbol of symbols) {
-    if (symbol.declarations.length === 0) return false;
+    if (declarationCount(symbol) === 0) return false;
     if (common === undefined) {
-      common = new Set(symbol.declarations);
+      common = new Set(getDeclarations(symbol));
       continue;
     }
     const next = new Set<Node>();
-    for (const d of symbol.declarations) if (common.has(d)) next.add(d);
+    for (const d of getDeclarations(symbol)) if (common.has(d)) next.add(d);
     if (next.size === 0) return false;
     common = next;
   }
@@ -1836,7 +1879,7 @@ function hasCommonDeclaration(symbols: Symbol[]): boolean {
 
 export function createSymbolWithType(c: Checker, source: Symbol, t: Type | undefined): Symbol {
   const symbol = c.newSymbolWithCheckFlags(source.flags, source.name, source.checkFlags & CheckFlags.Readonly);
-  symbol.declarations = source.declarations;
+  copyDeclarations(symbol, source);
   symbol.parent = source.parent;
   symbol.valueDeclaration = source.valueDeclaration;
   const id = getSymbolId(symbol);
@@ -2111,7 +2154,8 @@ export function getReducedType(c: Checker, t: Type): Type {
  * private, are combined, and the costliest constituent's properties are only looked up by name.
  */
 function hasNeverReducedProperty(c: Checker, t: IntersectionType): boolean {
-  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)) return true;
     return false;

package/src/compiler/checker-modules.ts

@@ -112,7 +112,6 @@ import {
   tryExtractTSExtension,
   tryGetExtensionFromPath,
 } from './path.js';
-import { InternalSymbolName, type Symbol, SymbolFlags, type SymbolTable, getSymbolId } from './symbol.js';
 import { SyntaxKind } from './syntax-kind.js';
 import { isExpressionNode } from './transformers/alias-references.js';
 import { type Checker, type CheckerHost, createDiagnosticForNode } from './checker.js';
@@ -162,6 +161,17 @@ 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,
+  InternalSymbolName,
+  setDeclarations,
+  type Symbol,
+  SymbolFlags,
+  type SymbolTable,
+} from './symbol.js';
 
 // ---- Resolution
 
@@ -787,7 +797,7 @@ function isOnlyImportableAsDefault(c: Checker, usage: Node, resolvedModule: Symb
 function getSourceFileOfModuleSymbol(symbol: Symbol): SourceFile | undefined {
   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;
@@ -857,7 +867,7 @@ function createDefaultPropertyWrapperForModule(
 
 function cloneTypeAsModuleType(c: Checker, symbol: Symbol, moduleType: Type): Symbol {
   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);
   if (symbol.exports !== undefined) result.exports = new Map(symbol.exports);
@@ -869,7 +879,7 @@ function cloneTypeAsModuleType(c: Checker, symbol: Symbol, moduleType: Type): Sy
 
 function getSourceFileDeclaration(symbol: Symbol | undefined): SourceFile | undefined {
   if (symbol === undefined) return undefined;
-  for (const d of symbol.declarations) if (d.kind === SyntaxKind.SourceFile) return d as SourceFile;
+  for (const d of getDeclarations(symbol)) if (d.kind === SyntaxKind.SourceFile) return d as SourceFile;
   return undefined;
 }
 
@@ -919,7 +929,7 @@ function canHaveSyntheticDefault(
 }
 
 function hasSyntacticDefault(symbol: Symbol): boolean {
-  for (const d of symbol.declarations) if (isSyntacticDefault(d)) return true;
+  for (const d of getDeclarations(symbol)) if (isSyntacticDefault(d)) return true;
   return false;
 }
 
@@ -1154,7 +1164,7 @@ function reportNonDefaultExport(c: Checker, moduleSymbol: Symbol, node: Node): v
   );
   const exportStar = moduleSymbol.exports?.get(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 !== SyntaxKind.ExportDeclaration || specifier === undefined) continue;
     const resolved = resolveExternalModuleName(c, d, specifier, false);
@@ -1304,9 +1314,9 @@ function combineValueAndTypeSymbols(c: Checker, valueSymbol: Symbol, typeSymbol:
   if ((typeSymbol.flags & SymbolFlags.Value) !== 0) return typeSymbol;
   if ((valueSymbol.flags & (SymbolFlags.Type | 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) if (!declarations.includes(d)) declarations.push(d);
-  result.declarations = declarations;
+  const declarations = getDeclarations(valueSymbol).slice();
+  for (const d of getDeclarations(typeSymbol)) if (!declarations.includes(d)) declarations.push(d);
+  setDeclarations(result, declarations);
   result.parent = valueSymbol.parent ?? typeSymbol.parent;
   result.valueDeclaration = valueSymbol.valueDeclaration;
   if (typeSymbol.members !== undefined) result.members = new Map(typeSymbol.members);
@@ -1412,10 +1422,10 @@ function reportNonExportedMember(
           symbolToString(c, exportedSymbol),
         )
       : c.error(name, Diagnostics.Module_0_declares_1_locally_but_it_is_not_exported, moduleName, declarationName);
-  for (let i = 0; i < localSymbol.declarations.length; i++)
+  for (let i = 0; i < declarationCount(localSymbol); i++)
     diagnostic.addRelatedInfo(
       createDiagnosticForNode(
-        localSymbol.declarations[i]!,
+        declarationAt(localSymbol, i),
         i === 0 ? Diagnostics.X_0_is_declared_here : Diagnostics.X_and_here,
         [declarationName],
       ),
@@ -1985,7 +1995,7 @@ class ExportCollector {
     if (exportStars !== undefined) {
       const nested: SymbolTable = new Map<string, Symbol>();
       const lookupTable = new Map<string, ExportCollision>();
-      for (const node of exportStars.declarations) {
+      for (const node of getDeclarations(exportStars)) {
         const specifier = (node as ExportDeclaration).moduleSpecifier;
         const resolved = resolveExternalModuleName(this.c, node, specifier, false);
         const exported = this.visit(resolved, node, isTypeOnly || getIsTypeOnly(node));
@@ -2551,7 +2561,7 @@ function checkExportSpecifier(c: Checker, node: Node): void {
     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,

package/src/compiler/checker-object-literals.ts

@@ -16,7 +16,6 @@ import {
 import { isAssignmentTarget } from './binder-utilities.js';
 import { createDiagnosticForNode, type Checker } from './checker.js';
 import { Diagnostics } from './diagnostics.js';
-import { CheckFlags, type Symbol, SymbolFlags, internalSymbolNamePrefix, getSymbolId } from './symbol.js';
 import { SyntaxKind } from './syntax-kind.js';
 import {
   CheckMode,
@@ -46,6 +45,8 @@ import {
   getPropertiesOfType,
   getPropertyOfType,
   getReducedType,
+  keepPropertiesOnly,
+  scannedLiteralPropertiesLimit,
 } from './checker-members.js';
 import { symbolToString, typeToString } from './type-printer.js';
 import { getMergedSymbol, getSymbolOfDeclaration } from './checker-symbols.js';
@@ -76,6 +77,17 @@ import {
 import { addIntraExpressionInferenceSite } from './checker-inference.js';
 import { isEmptyObjectType } from './checker-type-factory.js';
 import { getTypeOfExpandoObjectLiteral, isJSObjectLiteral } from './checker-javascript.js';
+import {
+  CheckFlags,
+  copyDeclarations,
+  declarationCount,
+  getDeclarations,
+  getSymbolId,
+  internalSymbolNamePrefix,
+  setDeclarations,
+  type Symbol,
+  SymbolFlags,
+} from './symbol.js';
 
 /** Builds the type of the members collected since the last spread. */
 class ObjectLiteralBuilder {
@@ -123,6 +135,8 @@ class ObjectLiteralBuilder {
     if (this.patternWithComputedProperties)
       result.objectFlags |= 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;
   }
 
@@ -229,7 +243,7 @@ export function checkObjectLiteral(c: Checker, node: Node, checkMode: CheckMode)
             typeToString(c, contextualType!),
           );
       }
-      prop.declarations = member.declarations;
+      copyDeclarations(prop, member);
       prop.parent = member.parent;
       prop.valueDeclaration = member.valueDeclaration;
       c.symbolTypes.set(id, t);
@@ -317,7 +331,7 @@ function getObjectLiteralIndexInfo(c: Checker, isReadonly: boolean, properties:
       (keyType === c.esSymbolType && isSymbolWithSymbolName(c, prop))
     ) {
       propTypes.push(getTypeOfSymbol(c, prop));
-      if (isSymbolWithComputedName(prop)) components.push(prop.declarations[0]!);
+      if (isSymbolWithComputedName(prop)) components.push(prop.declaration!);
     }
   }
   const unionType =
@@ -328,7 +342,7 @@ function getObjectLiteralIndexInfo(c: Checker, isReadonly: boolean, properties:
 }
 
 function getFirstDeclarationName(symbol: Symbol): Node | undefined {
-  return symbol.declarations.length !== 0 ? getName(symbol.declarations[0]!) : undefined;
+  return declarationCount(symbol) !== 0 ? getName(symbol.declaration!) : undefined;
 }
 
 function isSymbolWithSymbolName(c: Checker, symbol: Symbol): boolean {
@@ -470,7 +484,7 @@ export function getSpreadType(
     );
     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);
   }
@@ -479,6 +493,7 @@ export function getSpreadType(
   const spread = createAnonymousType(c, symbol, members, [], [], spreadIndexInfos);
   spread.objectFlags |=
     ObjectFlags.ObjectLiteral | ObjectFlags.ContainsObjectOrArrayLiteral | ObjectFlags.ContainsSpread | objectFlags;
+  keepPropertiesOnly(c, spread, members, scannedLiteralPropertiesLimit);
   return spread;
 }
 
@@ -564,12 +579,13 @@ function tryMergeUnionOfObjectTypeAndEmptyObject(c: Checker, t: Type, readonly:
       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 |= ObjectFlags.ObjectLiteral | ObjectFlags.ContainsObjectOrArrayLiteral;
+  keepPropertiesOnly(c, spread, members, scannedLiteralPropertiesLimit);
   return spread;
 }

package/src/compiler/checker-overloads.ts

@@ -23,7 +23,6 @@ import {
 } from './binder-utilities.js';
 import { nodeIsMissing, nodeIsPresent } from './ast-utilities.js';
 import { type DiagnosticMessage, Diagnostics } from './diagnostics.js';
-import { type Symbol, SymbolFlags } from './symbol.js';
 import { SyntaxKind } from './syntax-kind.js';
 import { type Checker, createDiagnosticForNode } from './checker.js';
 import type { Signature } from './checker-types.js';
@@ -39,6 +38,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, type Symbol, SymbolFlags } from './symbol.js';
 
 /** Checks the overloads of a function or method declaration's local and export symbols. */
 export function checkFunctionOrMethodSymbols(c: Checker, node: Node): void {
@@ -84,7 +84,7 @@ class OverloadChecker {
 
   check(): void {
     const c = this.c;
-    const declarations = this.symbol.declarations;
+    const declarations = getDeclarations(this.symbol);
     let someNodeFlags = ModifierFlags.None;
     let allNodeFlags = flagsToCheck();
     let someHaveQuestionToken = false;
@@ -184,8 +184,8 @@ class OverloadChecker {
   reportClassMergedWithFunction(): void {
     const c = this.c;
     const classes: Node[] = [];
-    for (const d of this.symbol.declarations) if (d.kind === SyntaxKind.ClassDeclaration) classes.push(d);
-    for (const d of this.symbol.declarations) {
+    for (const d of getDeclarations(this.symbol)) if (d.kind === SyntaxKind.ClassDeclaration) classes.push(d);
+    for (const d of getDeclarations(this.symbol)) {
       let message: DiagnosticMessage;
       if (d.kind === SyntaxKind.ClassDeclaration)
         message = Diagnostics.Class_declaration_cannot_implement_overload_list_for_0;
@@ -201,7 +201,7 @@ class OverloadChecker {
   }
 
   checkFlagAgreement(
-    overloads: Node[],
+    overloads: readonly Node[],
     implementation: Node | undefined,
     someOverloadFlags: ModifierFlags,
     allOverloadFlags: ModifierFlags,
@@ -290,7 +290,7 @@ class OverloadChecker {
  * The declaration whose flags overloads must agree with: the implementation when it shares the first
  * overload's container (so overloads from other files aren't reported), else the first overload.
  */
-function getCanonicalOverload(overloads: Node[], implementation: Node | undefined): Node {
+function getCanonicalOverload(overloads: readonly Node[], implementation: Node | undefined): Node {
   return implementation !== undefined && implementation.parent === overloads[0]!.parent
     ? implementation
     : overloads[0]!;

package/src/compiler/checker-property-access.ts

@@ -37,7 +37,6 @@ import {
 import { isFunctionLike, isInJSFile } from './ast-utilities.js';
 import { type Checker, createDiagnosticForNode } from './checker.js';
 import { type Diagnostic, Diagnostics } from './diagnostics.js';
-import { CheckFlags, type Symbol, SymbolFlags, getSymbolId } from './symbol.js';
 import { SyntaxKind } from './syntax-kind.js';
 import {
   CheckMode,
@@ -102,6 +101,7 @@ import {
   getResolvedSymbol,
 } from './checker-expressions.js';
 import { isJSLiteralType, isThisPropertyAccessInConstructor } from './checker-javascript.js';
+import { CheckFlags, getDeclarations, getSymbolId, type Symbol, SymbolFlags } from './symbol.js';
 
 export function checkPropertyAccessExpressionOrQualifiedName(
   c: Checker,
@@ -607,7 +607,7 @@ function checkPropertyAccessibilityAtLocation(
 }
 
 function hasClassInstancePropertyDeclaration(symbol: Symbol): boolean {
-  for (const d of symbol.declarations) if (isClassInstanceProperty(d)) return true;
+  for (const d of getDeclarations(symbol)) if (isClassInstanceProperty(d)) return true;
   return false;
 }
 

package/src/compiler/checker-services.ts

@@ -126,7 +126,7 @@ import {
 } from './checker-type-nodes.js';
 import { CheckMode, type Signature, type Type } from './checker-types.js';
 import { getNodeAtPosition } from './parser.js';
-import { CheckFlags, InternalSymbolName, type Symbol, SymbolFlags, getSymbolId } from './symbol.js';
+import { CheckFlags, getSymbolId, InternalSymbolName, setDeclarations, type Symbol, SymbolFlags } from './symbol.js';
 import { SyntaxKind } from './syntax-kind.js';
 
 // ---- Symbols at locations
@@ -397,7 +397,7 @@ function getApplicableIndexSymbol(c: Checker, t: Type, keyType: Type): Symbol |
           declarations.push(other.declaration);
     if (declarations.length !== 0) {
       const symbol = c.newSymbolWithCheckFlags(SymbolFlags.Property, InternalSymbolName.Index, CheckFlags.IndexSymbol);
-      symbol.declarations = declarations;
+      setDeclarations(symbol, declarations);
       symbol.valueDeclaration = declarations[0]!;
       symbol.parent = t.symbol;
       c.symbolTypes.set(getSymbolId(symbol), info.valueType);