tsc-ts 0.0.5 → 0.0.7

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

@@ -18,6 +18,7 @@ import { getFlowTypeOfReference, isMatchingReference } from './checker-narrowing
 import { isEmptyArrayLiteralType } from './relations.js';
 import { getTypeOfSymbol, getWidenedType, reportImplicitAny } from './checker-symbol-types.js';
 import { getFlowTypeInConstructor, getFlowTypeOfProperty, getTypeOfPropertyInBaseClass, isAutoTypedProperty, } from './checker-classes.js';
+import { declarationCount, getDeclarations } from './symbol.js';
 /** The type of the CommonJS `module` symbol or its `exports` property. */
 export function getTypeOfModuleExportsSymbol(c, symbol) {
     if (symbol.name === 'exports') {
@@ -39,7 +40,7 @@ export function getWidenedTypeForAssignmentDeclaration(c, symbol) {
         t = getTypeOfPropertyInBaseClass(c, symbol);
     if (t === undefined) {
         const types = [];
-        const declarations = symbol.declarations;
+        const declarations = getDeclarations(symbol);
         for (let i = 0; i < declarations.length; i++) {
             const declaration = declarations[i];
             const declaredType = declaration instanceof BinaryExpression ? declaration.type : undefined;
@@ -170,7 +171,7 @@ function getThisAssignmentKind(c, symbol) {
         return (links.thisAssignmentKind - 1);
     let allThis = true;
     let typeAnnotation;
-    for (const declaration of symbol.declarations) {
+    for (const declaration of getDeclarations(symbol)) {
         if (!(declaration instanceof BinaryExpression)) {
             allThis = false;
             break;
@@ -210,7 +211,7 @@ export function isConstructorDeclaredThisProperty(c, symbol) {
     return getThisAssignmentKind(c, symbol) === 2 /* ThisAssignmentKind.Constructor */;
 }
 function getDeclaringConstructor(symbol) {
-    for (const declaration of symbol.declarations) {
+    for (const declaration of getDeclarations(symbol)) {
         const container = getThisContainer(declaration, false, false);
         if (container.kind === 177 /* SyntaxKind.Constructor */)
             return container;
@@ -437,5 +438,5 @@ export function isUndefinedAssignmentToCommonJSExport(c, left, rightType) {
     if (getAssignmentDeclarationKind(assignment) !== 2 /* JSDeclarationKind.ExportsProperty */)
         return false;
     const symbol = c.resolvedSymbols.get(left.id);
-    return symbol !== undefined && symbol.declarations.length > 1 && (rightType.flags & 4 /* TypeFlags.Undefined */) !== 0;
+    return symbol !== undefined && declarationCount(symbol) > 1 && (rightType.flags & 4 /* TypeFlags.Undefined */) !== 0;
 }

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

@@ -1,11 +1,11 @@
 import { type JsxAttributes, type Node, type SourceFile } from './ast.js';
 import { Diagnostic } from './diagnostics.js';
-import { type Symbol } from './symbol.js';
 import { type Checker } from './checker.js';
 import { CheckMode, type Signature, type Type } from './checker-types.js';
 import { type Relation } from './relations.js';
 import { ContextFlags } from './checker-contextual.js';
 import { type InferenceContext } from './checker-inference.js';
+import { type Symbol } from './symbol.js';
 declare const enum JsxFlags {
     None = 0,
     /** An element from a named property of `JSX.IntrinsicElements`. */

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

@@ -6,7 +6,6 @@ import { Diagnostic, chainDiagnostic } from './diagnostics.js';
 import { JsxEmit } from './options.js';
 import { parseIsolatedEntityName } from './parser.js';
 import { skipTrivia } from './scanner.js';
-import { getSymbolId } from './symbol.js';
 import { createDiagnosticForNode } from './checker.js';
 import { newTypeMapper, } from './checker-types.js';
 import { createAnonymousType, createArrayType, createTupleType, createTypeReference, getIntersectionType, getPropagatingFlagsOfTypes, getStringLiteralType, getUnionType, intersectTypes, isErrorType, everyType, isArrayType, mapTypeEx, someType, typesOf, } from './checker-type-factory.js';
@@ -38,6 +37,7 @@ import { getIndexedAccessType } from './checker-type-operators.js';
 import { filterType, isTupleType } from './checker-type-factory.js';
 import { createTypeFromGenericGlobalType } from './checker-type-factory.js';
 import { isTypeAssignableTo } from './relations.js';
+import { copyDeclarations, declarationCount, getSymbolId, } from './symbol.js';
 // Names in the `JSX` namespace.
 const jsxNamespaceName = 'JSX';
 const jsxIntrinsicElementsName = 'IntrinsicElements';
@@ -384,8 +384,8 @@ function getNameFromJsxElementAttributesContainer(c, containerName, ns) {
                 return '';
             if (props.length === 1)
                 return props[0].name;
-            if (sym.declarations.length !== 0)
-                c.error(sym.declarations[0], 752 /* Diagnostics.The_global_type_JSX_0_may_not_have_more_than_one_property */, containerName);
+            if (declarationCount(sym) !== 0)
+                c.error(sym.declaration, 752 /* Diagnostics.The_global_type_JSX_0_may_not_have_more_than_one_property */, containerName);
         }
     }
     return "\uFFFEmissing" /* InternalSymbolName.Missing */;
@@ -733,7 +733,7 @@ export function createJsxAttributesTypeFromAttributesProperty(c, openingLikeElem
                 const exprType = checkJsxAttribute(c, attributeDecl, checkMode);
                 objectFlags |= exprType.objectFlags & 458752 /* ObjectFlags.PropagatingFlags */;
                 const attributeSymbol = c.newSymbol(4 /* SymbolFlags.Property */ | member.flags, member.name);
-                attributeSymbol.declarations = member.declarations;
+                copyDeclarations(attributeSymbol, member);
                 attributeSymbol.parent = member.parent;
                 if (member.valueDeclaration !== undefined)
                     attributeSymbol.valueDeclaration = member.valueDeclaration;

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

@@ -1,4 +1,4 @@
-import { getSymbolId } from './symbol.js';
+import { copyDeclarations, getSymbolId } from './symbol.js';
 import { cachedTypeKey } from './checker-types.js';
 import { createAnonymousType } from './checker-type-factory.js';
 import { getPropertiesOfObjectType, resolveStructuredTypeMembers } from './checker-members.js';
@@ -29,7 +29,7 @@ export function getRegularTypeOfObjectLiteral(c, t) {
 }
 function createSymbolWithTypeLocal(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);

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. */
@@ -140,6 +142,33 @@ export declare function getPropertyOfType(c: Checker, t: Type, name: string): Sy
  * primitives and type parameters, and falls back to Object and Function members.
  */
 export declare function getPropertyOfTypeEx(c: Checker, t: Type, name: string, skipObjectFunctionPropertyAugment: boolean, includeTypeOnlyMembers: boolean): Symbol | 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 declare class PropertyListIndex {
+    readonly positions: Map<string, number>;
+    readonly staticPrivate: number[];
+    readonly required: number[];
+    constructor(positions: Map<string, number>, staticPrivate: number[], required: number[]);
+}
+/**
+ * `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 declare function firstUnmatchedProperty(c: Checker, targetProperties: Symbol[], found: number[], requireOptionalProperties: boolean): Symbol | 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 declare function positionsOfNamesFoundInSource(c: Checker, source: Type, target: Type, targetProperties: Symbol[]): number[] | undefined;
 export declare function getPropertyOfObjectType(c: Checker, t: Type, name: string): Symbol | undefined;
 export declare function getTypeOfPropertyOfType(c: Checker, t: Type, name: string): Type | undefined;
 export declare function getPropertyOfUnionOrIntersectionType(c: Checker, t: UnionOrIntersectionType, name: string, skipObjectFunctionPropertyAugment: boolean): Symbol | undefined;

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);
@@ -1290,6 +1305,171 @@ export function getPropertyOfTypeEx(c, t, name, skipObjectFunctionPropertyAugmen
         return getPropertyOfUnionOrIntersectionType(c, t, name, skipObjectFunctionPropertyAugment);
     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 {
+    positions;
+    staticPrivate;
+    required;
+    constructor(positions, staticPrivate, required) {
+        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, target, properties) {
+    const known = c.propertyListIndexes.get(properties);
+    if (known instanceof PropertyListIndex)
+        return known;
+    if (known === null)
+        return undefined;
+    let positions;
+    const pending = (target.flags & 1048576 /* 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() : undefined;
+    const staticPrivate = [];
+    const required = [];
+    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 & 16777216 /* SymbolFlags.Optional */) === 0 && (p.checkFlags & 48 /* 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, targetProperties, found, requireOptionalProperties) {
+    const index = c.propertyListIndexes.get(targetProperties);
+    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, t) {
+    const holder = (t.objectFlags & 2097152 /* ObjectFlags.MembersResolved */) !== 0 ? t : membersHolder(c, t);
+    if ((holder.objectFlags & 2097152 /* 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, source, target, targetProperties) {
+    if (targetProperties.length < indexedTargetPropertiesMinimum)
+        return undefined;
+    if ((source.flags & 1048576 /* 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 & 512 /* SymbolFlags.ValueModule */) !== 0)
+        return undefined;
+    const sourceProperties = resolvedPropertiesIfAny(c, source);
+    if (sourceProperties === undefined)
+        return undefined;
+    const resolved = membersHolder(c, source);
+    let functionType;
+    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 & 1048576 /* TypeFlags.Object */) !== 0) {
+        const properties = resolvedPropertiesIfAny(c, functionType);
+        if (properties === undefined)
+            return undefined;
+        functionProperties = properties;
+    }
+    const objectProperties = (c.globalObjectType.flags & 1048576 /* 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 = [];
+    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, t, name) {
     if ((t.flags & 1048576 /* TypeFlags.Object */) === 0)
         return undefined;
@@ -1316,18 +1496,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 +1669,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 +1693,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 +1727,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 +1745,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 +2005,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))