tsc-ts 0.0.6 → 0.0.8

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

@@ -12,7 +12,7 @@ import { entityNameToString } from './checker-expressions.js';
 import { isErrorType } from './checker-type-factory.js';
 import { getPropertyOfType } from './checker-members.js';
 import { signatureToString } from './type-printer.js';
-import { declarationCount, getDeclarations } from './symbol.js';
+import { declarationAt, declarationCount, getDeclarations } from './symbol.js';
 /** Whether `declaration`, or the statement it belongs to, has a `@deprecated` JSDoc tag. */
 export function isDeprecatedDeclaration(declaration) {
     if ((getCombinedNodeFlags(declaration) & 67108864 /* NodeFlags.PossiblyContainsDeprecatedTag */) === 0)
@@ -38,24 +38,24 @@ function getJSDocDeprecatedTag(node) {
  * members when all are.
  */
 export function isDeprecatedSymbol(c, symbol) {
-    const declarations = getDeclarations(symbol);
+    const count = declarationCount(symbol);
     const parentSymbol = getParentOfSymbol(c, symbol);
-    if (parentSymbol !== undefined && declarations.length > 1)
+    if (parentSymbol !== undefined && count > 1)
         return (parentSymbol.flags & 64 /* SymbolFlags.Interface */) !== 0
-            ? someDeprecatedDeclaration(declarations)
-            : everyDeprecatedDeclaration(declarations);
+            ? someDeprecatedDeclaration(symbol)
+            : everyDeprecatedDeclaration(symbol);
     return ((symbol.valueDeclaration !== undefined && isDeprecatedDeclaration(symbol.valueDeclaration)) ||
-        (declarations.length !== 0 && everyDeprecatedDeclaration(declarations)));
+        (count !== 0 && everyDeprecatedDeclaration(symbol)));
 }
-function someDeprecatedDeclaration(declarations) {
-    for (const d of declarations)
-        if (isDeprecatedDeclaration(d))
+function someDeprecatedDeclaration(symbol) {
+    for (let i = 0; i < declarationCount(symbol); i++)
+        if (isDeprecatedDeclaration(declarationAt(symbol, i)))
             return true;
     return false;
 }
-function everyDeprecatedDeclaration(declarations) {
-    for (const d of declarations)
-        if (!isDeprecatedDeclaration(d))
+function everyDeprecatedDeclaration(symbol) {
+    for (let i = 0; i < declarationCount(symbol); i++)
+        if (!isDeprecatedDeclaration(declarationAt(symbol, i)))
             return false;
     return true;
 }
@@ -290,7 +290,8 @@ export function checkDeprecatedTypeReference(c, node, type) {
     const symbol = c.resolvedSymbols.get(node.id);
     if (symbol === undefined)
         return;
-    for (const d of getDeclarations(symbol)) {
+    for (let i = 0; i < declarationCount(symbol); i++) {
+        const d = declarationAt(symbol, i);
         if (isTypeDeclaration(d) && isDeprecatedDeclaration(d)) {
             addDeprecatedSuggestion(c, getDeprecatedSuggestionNode(node), getDeclarations(symbol), symbol.name);
             return;

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

@@ -22,7 +22,7 @@ import { getNonNullableType, getTypeWithFacts, hasTypeFacts } from './checker-fl
 import { sliceTupleType } from './checker-signatures.js';
 import { getPropertyNameFromType, isTypeUsableAsPropertyName, maybeTypeOfKind } from './checker-utilities.js';
 import { checkPropertyAccessibility } from './checker-property-access.js';
-import { copyDeclarations, getDeclarations, getSymbolId } from './symbol.js';
+import { copyDeclarations, declarationAt, declarationCount, getSymbolId, } from './symbol.js';
 function isBindingPatternNode(node) {
     return (node !== undefined &&
         (node.kind === 207 /* SyntaxKind.ObjectBindingPattern */ || node.kind === 208 /* SyntaxKind.ArrayBindingPattern */));
@@ -548,7 +548,8 @@ export function isSpreadableProperty(prop) {
     const notMethodOrAccessor = (prop.flags & (8192 /* SymbolFlags.Method */ | 32768 /* SymbolFlags.GetAccessor */ | 65536 /* SymbolFlags.SetAccessor */)) === 0;
     let hasPrivateName = false;
     let inClass = false;
-    for (const d of getDeclarations(prop)) {
+    for (let i = 0; i < declarationCount(prop); i++) {
+        const d = declarationAt(prop, i);
         if (isPrivateIdentifierClassElementDeclaration(d))
             hasPrivateName = true;
         if (d.parent !== undefined && isClassLike(d.parent))

package/dist/api/compiler/checker-emit-helpers.d.ts

@@ -45,7 +45,8 @@ declare class PendingHelperCheck {
 export declare class EmitHelperFileLinks {
     helpersModule: Symbol | undefined;
     requestedHelpers: number;
-    pending: PendingHelperCheck[];
+    /** Created on the first check; most files have none. */
+    pending: PendingHelperCheck[] | undefined;
 }
 /**
  * Under --importHelpers, the emit of the syntax at `location` calls `helpers` from tslib. Reports TS2354 when

package/dist/api/compiler/checker-emit-helpers.js

@@ -16,7 +16,8 @@ class PendingHelperCheck {
 export class EmitHelperFileLinks {
     helpersModule = undefined;
     requestedHelpers = 0 /* ExternalEmitHelpers.None */;
-    pending = [];
+    /** Created on the first check; most files have none. */
+    pending = undefined;
 }
 function fileLinks(c, file) {
     let links = c.emitHelperFileLinks.get(file);
@@ -45,7 +46,7 @@ export function checkExternalEmitHelpers(c, location, helpers) {
         const fileIndex = c.fileIndex.get(file);
         const checkingIndex = c.fileIndex.get(checking);
         if (fileIndex !== undefined && checkingIndex !== undefined && fileIndex < checkingIndex) {
-            fileLinks(c, file).pending.push(new PendingHelperCheck(location, helpers));
+            (fileLinks(c, file).pending ??= []).push(new PendingHelperCheck(location, helpers));
             return;
         }
     }
@@ -78,10 +79,10 @@ export function checkExternalEmitHelpers(c, location, helpers) {
 /** Runs the helper checks for nodes of `file` that were reached while checking later files. */
 export function checkPendingExternalEmitHelpers(c, file) {
     const links = c.emitHelperFileLinks.get(file);
-    if (links === undefined || links.pending.length === 0)
+    if (links?.pending === undefined)
         return;
     const pending = links.pending;
-    links.pending = [];
+    links.pending = undefined;
     for (const check of pending)
         checkExternalEmitHelpers(c, check.location, check.helpers);
 }

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

@@ -3,7 +3,7 @@
 // `checkGrammarSourceFile` walks a file once after it is type checked and runs the grammar checks
 // of each node in the order tsgo's checker runs them. Checks that need types read the checker's
 // caches. Errors reported with `grammarError*` are dropped when the file has parse errors.
-import { ElementAccessExpression, Identifier, NodeVisitor, StringLiteral, getAsteriskToken, getBody, getElements, getExpression, getHeritageClauses, getInitializer, getLabel, getIsTypeOnly, getLocals, getMembers, getModifiers, getName, getNodeId, getParameters, getPostfixToken, getStatements, getText, getType, getTypeArguments, getTypeParameters, isDeclarationNode, } from './ast.js';
+import { ElementAccessExpression, Identifier, NodeVisitor, StringLiteral, getAsteriskToken, getBody, getElements, getExpression, getHeritageClauses, getInitializer, getLabel, getIsTypeOnly, getLocals, getMembers, getModifiers, getName, getNodeId, getParameters, getPostfixToken, getStatements, getText, getType, getTypeArguments, getTypeParameters, isDeclarationNode, callQuestionDotToken, callTypeArguments, } from './ast.js';
 import { canHaveDecorators, canHaveIllegalDecorators, getExternalModuleName, getTextOfNodeFromSourceText, isAmbientModule, isFunctionLike, isFunctionLikeDeclarationKind, isModifierKind, isStringLiteralLike, modifierToFlag, nodeIsPresent, isInJSFile, } from './ast-utilities.js';
 import { getCombinedModifierFlags, getCombinedNodeFlags, getContainingClass, getRangeOfTokenAtPosition, getSourceFileOfNode, hasSyntacticModifier, isAutoAccessorPropertyDeclaration, isClassLike, isDynamicName, isEntityNameExpression, isExternalModule, isInTopLevelContext, isModuleAugmentationExternal, isPrivateIdentifierClassElementDeclaration, isStatic, skipParentheses, } from './binder-utilities.js';
 import { findUseStrictPrologue } from './binder.js';
@@ -858,8 +858,8 @@ function checkGrammarDecorator(g, decorator) {
             if (!canHaveCallExpression)
                 errorNode = node;
             // A `?.` token comes first, so it wins over an earlier error node.
-            if (call.questionDotToken !== undefined)
-                errorNode = call.questionDotToken;
+            if (callQuestionDotToken(call) !== undefined)
+                errorNode = callQuestionDotToken(call);
             node = call.expression;
             canHaveCallExpression = false;
             continue;
@@ -2380,7 +2380,7 @@ function checkGrammarCallExpression(g, node) {
     if (isImportCall)
         checkGrammarImportCallExpression(g, node);
     else
-        checkGrammarTypeArguments(g, node.typeArguments);
+        checkGrammarTypeArguments(g, callTypeArguments(node));
 }
 function checkGrammarImportCallExpression(g, node) {
     const moduleKind = g.moduleKind;
@@ -2394,7 +2394,7 @@ function checkGrammarImportCallExpression(g, node) {
     }
     else if (moduleKind === ModuleKind.ES2015)
         return grammarErrorOnNode(g, node, 259 /* Diagnostics.Dynamic_imports_are_only_supported_when_the_module_flag_is_set_to_es2020_es2022_esnext_commonjs_amd_system_umd_node16_node18_node20_or_nodenext */);
-    if (node.typeArguments !== undefined)
+    if (callTypeArguments(node) !== undefined)
         return grammarErrorOnNode(g, node, 262 /* Diagnostics.This_use_of_import_is_invalid_import_calls_can_be_written_but_they_must_have_parentheses_and_cannot_have_type_arguments */);
     const args = node.arguments;
     const argumentNodes = args.nodes;

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

@@ -56,28 +56,38 @@ export declare class IntraExpressionInferenceSite {
     readonly type: Type;
     constructor(node: Node, type: Type);
 }
-export declare class InferenceContext {
+/**
+ * The inferences for a set of type parameters. The context is its own fixing mapper (`mapper`), and
+ * each read of `nonFixingMapper` returns a new mapper that reads the context: no mapper the context
+ * holds refers back to it, so a context whose inference is done is freed by reference counting
+ * rather than by the cycle collector.
+ */
+export declare class InferenceContext extends TypeMapper {
+    readonly c: Checker;
     inferences: InferenceInfo[];
     /** The generic signature inferences are made for, if any. */
     readonly signature: Signature | undefined;
     flags: InferenceFlags;
     readonly compareTypes: TypeComparer;
-    /** Fixes inferences. */
-    mapper: TypeMapper;
-    nonFixingMapper: TypeMapper;
+    /** Combined after the non-fixing mapper (conditional types' `infer` constraints), if any. */
+    nonFixingOuter: TypeMapper | undefined;
     /** Maps to inferences from the return type, if any. */
     returnMapper: TypeMapper | undefined;
     outerReturnMapper: TypeMapper | undefined;
     inferredTypeParameters: Type[] | undefined;
-    intraExpressionInferenceSites: IntraExpressionInferenceSite[];
+    /** Created on the first site; most contexts get none. */
+    intraExpressionInferenceSites: IntraExpressionInferenceSite[] | undefined;
     constructor(c: Checker, inferences: InferenceInfo[], signature: Signature | undefined, flags: InferenceFlags, compareTypes: TypeComparer);
+    /** Fixes inferences. */
+    get mapper(): TypeMapper;
+    /** Maps to the current inferences without fixing them. */
+    get nonFixingMapper(): TypeMapper;
+    map(type: Type): Type;
 }
-/** Maps a context's type parameters to their inferred types, optionally fixing them. */
-export declare class InferenceTypeMapper extends TypeMapper {
-    readonly c: Checker;
+/** Maps a context's type parameters to their inferred types without fixing them. */
+export declare class NonFixingInferenceMapper extends TypeMapper {
     readonly context: InferenceContext;
-    readonly fixing: boolean;
-    constructor(c: Checker, context: InferenceContext, fixing: boolean);
+    constructor(context: InferenceContext);
     map(type: Type): Type;
 }
 export declare function createInferenceContext(c: Checker, typeParameters: readonly Type[], signature: Signature | undefined, flags: InferenceFlags, compareTypes: TypeComparer | undefined): InferenceContext;

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

@@ -61,57 +61,78 @@ export class IntraExpressionInferenceSite {
         this.type = type;
     }
 }
-export class InferenceContext {
+/**
+ * The inferences for a set of type parameters. The context is its own fixing mapper (`mapper`), and
+ * each read of `nonFixingMapper` returns a new mapper that reads the context: no mapper the context
+ * holds refers back to it, so a context whose inference is done is freed by reference counting
+ * rather than by the cycle collector.
+ */
+export class InferenceContext extends TypeMapper {
+    c;
     inferences;
     /** The generic signature inferences are made for, if any. */
     signature;
     flags;
     compareTypes;
-    /** Fixes inferences. */
-    mapper;
-    nonFixingMapper;
+    /** Combined after the non-fixing mapper (conditional types' `infer` constraints), if any. */
+    nonFixingOuter = undefined;
     /** Maps to inferences from the return type, if any. */
     returnMapper = undefined;
     outerReturnMapper = undefined;
     inferredTypeParameters = undefined;
-    intraExpressionInferenceSites = [];
+    /** Created on the first site; most contexts get none. */
+    intraExpressionInferenceSites = undefined;
     constructor(c, inferences, signature, flags, compareTypes) {
+        super();
+        this.c = c;
         this.inferences = inferences;
         this.signature = signature;
         this.flags = flags;
         this.compareTypes = compareTypes;
-        this.mapper = new InferenceTypeMapper(c, this, true);
-        this.nonFixingMapper = new InferenceTypeMapper(c, this, false);
     }
-}
-/** Maps a context's type parameters to their inferred types, optionally fixing them. */
-export class InferenceTypeMapper extends TypeMapper {
-    c;
-    context;
-    fixing;
-    constructor(c, context, fixing) {
-        super();
-        this.c = c;
-        this.context = context;
-        this.fixing = fixing;
+    /** Fixes inferences. */
+    get mapper() {
+        return this;
+    }
+    /** Maps to the current inferences without fixing them. */
+    get nonFixingMapper() {
+        const mapper = new NonFixingInferenceMapper(this);
+        const outer = this.nonFixingOuter;
+        return outer !== undefined ? combineTypeMappers(this.c, mapper, outer) : mapper;
     }
     map(type) {
-        const inferences = this.context.inferences;
+        const inferences = this.inferences;
         for (let i = 0; i < inferences.length; i++) {
             const inference = inferences[i];
             if (type !== inference.typeParameter)
                 continue;
-            if (this.fixing && !inference.isFixed) {
+            if (!inference.isFixed) {
                 // Infer from intra-expression sites before committing to an inference.
-                inferFromIntraExpressionSites(this.c, this.context);
+                inferFromIntraExpressionSites(this.c, this);
                 clearCachedInferences(inferences);
                 inference.isFixed = true;
             }
-            return getInferredType(this.c, this.context, i);
+            return getInferredType(this.c, this, i);
         }
         return type;
     }
 }
+/** Maps a context's type parameters to their inferred types without fixing them. */
+export class NonFixingInferenceMapper extends TypeMapper {
+    context;
+    constructor(context) {
+        super();
+        this.context = context;
+    }
+    map(type) {
+        const context = this.context;
+        const inferences = context.inferences;
+        for (let i = 0; i < inferences.length; i++)
+            if (type === inferences[i].typeParameter)
+                return getInferredType(context.c, context, i);
+        return type;
+    }
+}
 export function createInferenceContext(c, typeParameters, signature, flags, compareTypes) {
     const inferences = [];
     for (const tp of typeParameters)
@@ -144,7 +165,7 @@ export function createOuterReturnMapper(c, context) {
     return context.outerReturnMapper;
 }
 export function addIntraExpressionInferenceSite(context, node, type) {
-    context.intraExpressionInferenceSites.push(new IntraExpressionInferenceSite(node, type));
+    (context.intraExpressionInferenceSites ??= []).push(new IntraExpressionInferenceSite(node, type));
 }
 export function clearCachedInferences(inferences) {
     for (const inference of inferences)
@@ -1678,7 +1699,9 @@ export function instantiateReverseMappedType(c, t, mapper) {
 /** Infers early from intra-expression sites (context-sensitive elements of object and array literals). */
 export function inferFromIntraExpressionSites(c, context) {
     const sites = context.intraExpressionInferenceSites;
-    context.intraExpressionInferenceSites = [];
+    if (sites === undefined)
+        return;
+    context.intraExpressionInferenceSites = undefined;
     for (const site of sites) {
         const contextualType = getContextualTypeForInference(c, site.node);
         if (contextualType !== undefined)
@@ -1940,7 +1963,7 @@ export function inferTypesForConditional(c, root, checkType, extendsType, mapper
     // so the non-fixing mapper combines with `mapper`.
     const context = createInferenceContext(c, root.inferTypeParameters, undefined, 0 /* InferenceFlags.None */, undefined);
     if (mapper !== undefined)
-        context.nonFixingMapper = combineTypeMappers(c, context.nonFixingMapper, mapper);
+        context.nonFixingOuter = mapper;
     // Inferences from constraints could eagerly resolve what should defer; contravariance is always strict.
     if (!checkTypeDeferred)
         inferTypes(c, context.inferences, checkType, extendsType, 512 /* InferencePriority.NoConstraints */ | 1024 /* InferencePriority.AlwaysStrict */, false);

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

@@ -142,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

@@ -1305,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;

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

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