tsc-ts 0.0.5 → 0.0.7

package/src/compiler/checker-literals.ts

@@ -1,6 +1,6 @@
 // Object literal types: freshness and regular forms.
 import type { Checker } from './checker.js';
-import { CheckFlags, type Symbol, getSymbolId } from './symbol.js';
+import { CheckFlags, copyDeclarations, getSymbolId, type Symbol } from './symbol.js';
 import { CachedTypeKind, cachedTypeKey, ObjectFlags, type Type, TypeFlags } from './checker-types.js';
 import { createAnonymousType } from './checker-type-factory.js';
 import { getPropertiesOfObjectType, resolveStructuredTypeMembers } from './checker-members.js';
@@ -41,7 +41,7 @@ export function getRegularTypeOfObjectLiteral(c: Checker, t: Type): Type {
 
 function createSymbolWithTypeLocal(c: Checker, source: Symbol, t: Type): 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);

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 {
@@ -1576,6 +1611,170 @@ export function getPropertyOfTypeEx(
   return undefined;
 }
 
+/**
+ * A long property list that `propertiesRelatedTo` walks: the position of each name, and the positions of
+ * the static private properties, which `getUnmatchedProperty` never reports, and of the required ones.
+ */
+export class PropertyListIndex {
+  readonly positions: Map<string, number>;
+  readonly staticPrivate: number[];
+  readonly required: number[];
+
+  constructor(positions: Map<string, number>, staticPrivate: number[], required: number[]) {
+    this.positions = positions;
+    this.staticPrivate = staticPrivate;
+    this.required = required;
+  }
+}
+
+/** The uses of a long property list after which `propertyListIndex` indexes it by a table of its own. */
+const propertyListUsesBeforeIndex = 3;
+
+/**
+ * The index of `properties`, the properties of `target`. Where the members of `target` are properties
+ * with shared names (`PropertyMembers` with `MemberNames`), the index reads the positions of those names.
+ * Other lists get a positions table of their own on the use after the first `propertyListUsesBeforeIndex`:
+ * most long lists are related only a few times, and the lists related many times hold most of the lookups
+ * the index saves. Undefined before that, and where the list repeats a name.
+ */
+function propertyListIndex(c: Checker, target: Type, properties: Symbol[]): PropertyListIndex | undefined {
+  const known = c.propertyListIndexes.get(properties);
+  if (known instanceof PropertyListIndex) return known;
+  if (known === null) return undefined;
+  let positions: Map<string, number> | undefined;
+  const pending = (target.flags & TypeFlags.Object) !== 0 ? membersHolder(c, target).pendingMembers : undefined;
+  if (
+    pending instanceof PropertyMembers &&
+    pending.materializedProperties === properties &&
+    pending.names !== undefined
+  ) {
+    // The names are the names of the properties, in order (hasMemberNames).
+    positions = pending.names.positions;
+    if (positions.size !== properties.length) {
+      c.propertyListIndexes.set(properties, null);
+      return undefined;
+    }
+  } else {
+    const uses = known ?? 0;
+    if (uses < propertyListUsesBeforeIndex) {
+      c.propertyListIndexes.set(properties, uses + 1);
+      return undefined;
+    }
+  }
+  const own = positions === undefined ? new Map<string, number>() : undefined;
+  const staticPrivate: number[] = [];
+  const required: number[] = [];
+  for (let i = 0; i < properties.length; i++) {
+    const p = properties[i]!;
+    if (own !== undefined) {
+      if (own.has(p.name)) {
+        c.propertyListIndexes.set(properties, null);
+        return undefined;
+      }
+      own.set(p.name, i);
+    }
+    if (isStaticPrivateIdentifierProperty(p)) staticPrivate.push(i);
+    else if ((p.flags & SymbolFlags.Optional) === 0 && (p.checkFlags & CheckFlags.Partial) === 0) required.push(i);
+  }
+  const index = new PropertyListIndex((positions ?? own)!, staticPrivate, required);
+  c.propertyListIndexes.set(properties, index);
+  return index;
+}
+
+/**
+ * `getUnmatchedProperty(c, source, target, requireOptionalProperties, false)` where `targetProperties` are
+ * the target's properties and `found` the positions of the names the source has
+ * (`positionsOfNamesFoundInSource`): the first property that is not static private, and is required unless
+ * `requireOptionalProperties`, at a position not in `found`.
+ */
+export function firstUnmatchedProperty(
+  c: Checker,
+  targetProperties: Symbol[],
+  found: number[],
+  requireOptionalProperties: boolean,
+): Symbol | undefined {
+  const index = c.propertyListIndexes.get(targetProperties) as PropertyListIndex;
+  let next = 0;
+  if (!requireOptionalProperties) {
+    for (const position of index.required) {
+      while (next < found.length && found[next]! < position) next++;
+      if (next === found.length || found[next] !== position) return targetProperties[position];
+    }
+    return undefined;
+  }
+  const staticPrivate = index.staticPrivate;
+  let nextPrivate = 0;
+  for (let position = 0; position < targetProperties.length; position++) {
+    // A position can be both found and static private: both lists move past it.
+    const isFound = next < found.length && found[next] === position;
+    if (isFound) next++;
+    const isStaticPrivate = nextPrivate < staticPrivate.length && staticPrivate[nextPrivate] === position;
+    if (isStaticPrivate) nextPrivate++;
+    if (!isFound && !isStaticPrivate) return targetProperties[position];
+  }
+  return undefined;
+}
+
+/** The shortest target property list that `positionsOfNamesFoundInSource` indexes. */
+const indexedTargetPropertiesMinimum = 32;
+
+/** The properties of `t` where its members are resolved and instantiated, else undefined. */
+function resolvedPropertiesIfAny(c: Checker, t: Type): Symbol[] | undefined {
+  const holder = (t.objectFlags & ObjectFlags.MembersResolved) !== 0 ? (t as StructuredType) : membersHolder(c, t);
+  if ((holder.objectFlags & ObjectFlags.MembersResolved) === 0) return undefined;
+  const pending = holder.pendingMembers;
+  return pending === undefined || pending.materializedProperties !== undefined ? holder.properties : undefined;
+}
+
+/**
+ * The positions in `targetProperties`, the properties of `target`, ascending, of the names
+ * `getPropertyOfType(c, source, name)` finds: the names of the source's properties and of the Function and
+ * Object members its lookups fall back to. `getPropertyOfType` answers undefined for the names at every
+ * other position. Undefined where the answer cannot be read from resolved property lists without resolving
+ * anything (not an object type, an apparent type, members not resolved or not instantiated yet, a module),
+ * where the target list is too short or the source list too long to save lookups, and where the target
+ * list has no index (yet: `propertyListIndex`).
+ */
+export function positionsOfNamesFoundInSource(
+  c: Checker,
+  source: Type,
+  target: Type,
+  targetProperties: Symbol[],
+): number[] | undefined {
+  if (targetProperties.length < indexedTargetPropertiesMinimum) return undefined;
+  if ((source.flags & TypeFlags.Object) === 0 || !isOwnReducedApparentType(source)) return undefined;
+  // A module's member that only an `export type *` declaration exports is not found.
+  if (source.symbol !== undefined && (source.symbol.flags & SymbolFlags.ValueModule) !== 0) return undefined;
+  const sourceProperties = resolvedPropertiesIfAny(c, source);
+  if (sourceProperties === undefined) return undefined;
+  const resolved = membersHolder(c, source);
+  let functionType: Type | undefined;
+  if (source === c.anyFunctionType) functionType = c.globalFunctionType;
+  else if (resolved.callSignatures.length !== 0) functionType = c.globalCallableFunctionType;
+  else if (resolved.constructSignatures.length !== 0) functionType = c.globalNewableFunctionType;
+  let functionProperties = emptySymbols;
+  if (functionType !== undefined && (functionType.flags & TypeFlags.Object) !== 0) {
+    const properties = resolvedPropertiesIfAny(c, functionType);
+    if (properties === undefined) return undefined;
+    functionProperties = properties;
+  }
+  const objectProperties =
+    (c.globalObjectType.flags & TypeFlags.Object) !== 0 ? resolvedPropertiesIfAny(c, c.globalObjectType) : emptySymbols;
+  if (objectProperties === undefined) return undefined;
+  if ((sourceProperties.length + functionProperties.length + objectProperties.length) * 4 > targetProperties.length)
+    return undefined;
+  const index = propertyListIndex(c, target, targetProperties);
+  if (index === undefined) return undefined;
+  const positions = index.positions;
+  const found: number[] = [];
+  for (const list of [sourceProperties, functionProperties, objectProperties])
+    for (const p of list) {
+      const position = positions.get(p.name);
+      if (position !== undefined && !found.includes(position)) found.push(position);
+    }
+  return found.sort((a, b) => a - b);
+}
+
 export function getPropertyOfObjectType(c: Checker, t: Type, name: string): Symbol | undefined {
   if ((t.flags & TypeFlags.Object) === 0) return undefined;
   const symbol = getResolvedMember(resolveStructuredTypeMembers(c, t), name);
@@ -1614,16 +1813,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 +1972,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 +1990,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 +2028,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 +2043,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 +2318,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;