@cplieger/deadset-ts 6.1.1-dev.1 → 7.0.0-dev.2

package/dist/src/indexed-access.js

@@ -1,11 +1,11 @@
 /**
- * The members an indexed-access type names. `T["a" | "b"]` reads the members `a` and `b`
- * of `T` as a property access by either name would. Where the index is a type parameter
- * a call fixes, the call names the members the literal type argument names, written or
- * inferred, which is read off the parameter the type parameter annotates whole. The type
- * query of a type-query alias is no reference.
+ * The members an indexed-access type names: `T["a" | "b"]` reads `a` and `b` of `T`. An
+ * index naming a type parameter is read once the reference or the call holding it fixes
+ * that parameter, and a call of a method of a generic receiver fixes the receiver's by its
+ * type arguments. The type query of a type-query alias is no reference.
  */
-import { isArrowFunction, isCallExpression, isFunctionDeclaration, isFunctionExpression, isIdentifier, isIndexedAccessTypeNode, isLiteralTypeNode, isMethodDeclaration, isNewExpression, isNoSubstitutionTemplateLiteral, isNumericLiteral, isParenthesizedTypeNode, isPropertyAccessExpression, isStringLiteral, isTypeReferenceNode, isUnionTypeNode, SyntaxKind, } from "@typescript/native/unstable/ast";
+import { isArrowFunction, isCallExpression, isClassDeclaration, isClassExpression, isFunctionDeclaration, isFunctionExpression, isIdentifier, isNonNullExpression, isParenthesizedExpression, isNamedImports, isNamespaceImport, isImportDeclaration, isIndexedAccessTypeNode, isInterfaceDeclaration, isLiteralTypeNode, isMethodDeclaration, isMethodSignatureDeclaration, isNewExpression, isNoSubstitutionTemplateLiteral, isNumericLiteral, isParenthesizedTypeNode, isPropertyAccessExpression, isStringLiteral, isTypeAliasDeclaration, isTypeReferenceNode, isUnionTypeNode, isVariableDeclaration, } from "@typescript/native/unstable/ast";
+import { SymbolFlags } from "@typescript/native/unstable/sync";
 import { nodeKey } from "./inventory.js";
 import { renderPosition } from "./position.js";
 import { UNANSWERED } from "./query.js";
@@ -13,10 +13,19 @@ import { typeQueryAliases } from "./type-query-alias.js";
 function isGeneric(node) {
     return ((isFunctionDeclaration(node) ||
         isMethodDeclaration(node) ||
+        isMethodSignatureDeclaration(node) ||
         isArrowFunction(node) ||
-        isFunctionExpression(node)) &&
+        isFunctionExpression(node) ||
+        isTypeAliasDeclaration(node) ||
+        isInterfaceDeclaration(node) ||
+        isClassDeclaration(node) ||
+        isClassExpression(node)) &&
         node.typeParameters !== undefined);
 }
+/** Whether one generic is a receiver's: a class or an interface whose methods it parameterizes. */
+function isReceiver(node) {
+    return isInterfaceDeclaration(node) || isClassDeclaration(node) || isClassExpression(node);
+}
 function unwrappedType(node) {
     return isParenthesizedTypeNode(node) ? unwrappedType(node.type) : node;
 }
@@ -52,35 +61,141 @@ function literalTypeNames(type, parts) {
     }
     return names;
 }
+/** The type a fixed side stands for, or none where the site passes it on. */
+function concrete(fixed) {
+    return fixed.kind === "node" ? fixed.node : fixed.kind === "type" ? fixed.type : undefined;
+}
+/** The position of the type parameter `name` among the ones a generic declares, or -1. */
+function parameterAt(generic, name) {
+    return (generic.typeParameters ?? []).findIndex((parameter) => isIdentifier(parameter.name) && parameter.name.text === name);
+}
+/** The type parameter one type node names whole, among the enclosing generics, innermost first. */
+function namedParameter(node, enclosing) {
+    const type = unwrappedType(node);
+    if (!isTypeReferenceNode(type) ||
+        !isIdentifier(type.typeName) ||
+        type.typeArguments !== undefined) {
+        return undefined;
+    }
+    const spelled = type.typeName.text;
+    for (const generic of [...enclosing].reverse()) {
+        const index = parameterAt(generic, spelled);
+        if (index >= 0) {
+            return { generic, index };
+        }
+    }
+    return undefined;
+}
+/** The name a site writes to reach one generic: its own, or its variable's. */
+function calledName(generic) {
+    const own = generic.name;
+    if (own !== undefined && isIdentifier(own)) {
+        return own.text;
+    }
+    const parent = generic.parent;
+    return parent !== undefined && isVariableDeclaration(parent) && isIdentifier(parent.name)
+        ? parent.name.text
+        : undefined;
+}
+/** The generic a declaration a symbol names is: the function a variable is initialized with included. */
+function genericOf(node) {
+    if (isGeneric(node)) {
+        return node;
+    }
+    if (isVariableDeclaration(node) &&
+        node.initializer !== undefined &&
+        isGeneric(node.initializer)) {
+        return node.initializer;
+    }
+    return undefined;
+}
+/**
+ * Each indexed access inside one generic whose index names a type parameter of it, read
+ * from its own text: the object side is a type parameter of the same generic, one of the
+ * receiver it is a method of, or a type it writes.
+ */
+function carriedIn(generic) {
+    const found = [];
+    const receiver = generic.parent;
+    const outer = receiver !== undefined && isReceiver(receiver) && isGeneric(receiver) ? receiver : undefined;
+    const visit = (node) => {
+        if (isIndexedAccessTypeNode(node)) {
+            const index = namedParameter(node.indexType, [generic]);
+            if (index !== undefined) {
+                const own = namedParameter(node.objectType, [generic]);
+                const fromReceiver = own === undefined && outer !== undefined
+                    ? namedParameter(node.objectType, [outer])
+                    : undefined;
+                const object = own !== undefined
+                    ? { kind: "parameter", index: own.index }
+                    : fromReceiver !== undefined
+                        ? { kind: "receiver", index: fromReceiver.index }
+                        : { kind: "written", node: node.objectType };
+                found.push({ object, index: { kind: "parameter", index: index.index } });
+            }
+        }
+        if (node !== generic && isGeneric(node)) {
+            return;
+        }
+        node.forEachChild(visit);
+    };
+    visit(generic);
+    return found;
+}
 /**
  * The references the indexed-access types of one project's own files make to the members
- * they name, each made by the declaration that holds the type or the call, or by the file.
+ * they name, each made by the declaration that holds the type, the reference or the call,
+ * or by the file.
  */
 export function indexedAccessReferences(project, held, chains, root, testFiles) {
     const queries = project.queries;
     const accesses = [];
-    const generics = new Map();
-    const calls = [];
+    const carried = new Map();
     const names = new Set();
+    const sites = [];
+    /**
+     * Calls passing a literal argument whose callee a package binding heads, or that call a
+     * method, which a dependency's generic may fix.
+     */
+    const literalCalls = [];
+    const carry = (generic, one) => {
+        const known = carried.get(generic) ?? [];
+        const same = known.some((other) => JSON.stringify(sideKey(other)) === JSON.stringify(sideKey(one)));
+        if (same) {
+            return false;
+        }
+        carried.set(generic, [...known, one]);
+        const name = calledName(generic);
+        if (name !== undefined) {
+            names.add(name);
+        }
+        return true;
+    };
     for (const file of project.ownSourceFiles()) {
         const fileId = held.declarations.get(nodeKey(file, file));
         if (fileId === undefined) {
             continue;
         }
         const aliasTypes = new Set(typeQueryAliases(file).map((alias) => alias.type));
+        const imported = packageBindings(file);
         const visit = (node, from, enclosing) => {
             const own = held.declarations.get(nodeKey(file, node));
             const holder = own ?? from;
             const inside = isGeneric(node) ? [...enclosing, node] : enclosing;
+            if (isGeneric(node)) {
+                carriedIn(node).forEach((one) => carry(node, one));
+            }
             if (isIndexedAccessTypeNode(node) && !aliasTypes.has(node)) {
                 const literal = literalNames(node.indexType);
                 if (literal !== undefined) {
-                    accesses.push({ file, from: holder, at: node, object: node.objectType, names: literal });
-                }
-                else {
-                    parameterIndex(node, inside, file, generics, names);
+                    accesses.push({ file, from: holder, at: node, object: node.objectType, index: literal });
                 }
             }
+            if (isTypeReferenceNode(node) &&
+                node.typeArguments !== undefined &&
+                isIdentifier(node.typeName)) {
+                sites.push({ file, from: holder, node, name: node.typeName.text, enclosing: inside });
+            }
             if (isCallExpression(node) || isNewExpression(node)) {
                 const callee = node.expression;
                 const name = isIdentifier(callee)
@@ -89,7 +204,16 @@ export function indexedAccessReferences(project, held, chains, root, testFiles)
                         ? callee.name.text
                         : undefined;
                 if (name !== undefined) {
-                    calls.push({ file, from: holder, call: node, name });
+                    const site = { file, from: holder, node, name, enclosing: inside };
+                    sites.push(site);
+                    const literal = (node.arguments ?? []).some((argument) => isStringLiteral(argument) || isNumericLiteral(argument));
+                    const head = rootName(callee);
+                    const method = isPropertyAccessExpression(callee);
+                    if (literal &&
+                        isCallExpression(node) &&
+                        (method || (head !== undefined && imported.has(head)))) {
+                        literalCalls.push(site);
+                    }
                 }
             }
             node.forEachChild((child) => {
@@ -100,45 +224,198 @@ export function indexedAccessReferences(project, held, chains, root, testFiles)
             visit(child, fileId, []);
         });
     }
-    for (const { file, from, call, name } of calls) {
-        if (!names.has(name)) {
-            continue;
-        }
-        const resolved = queries.resolvedSignature(call);
-        if (resolved === UNANSWERED || resolved?.declaration === undefined) {
-            continue;
+    function partsOf(type) {
+        const parts = queries.constituents(type);
+        return parts === UNANSWERED ? [type] : parts;
+    }
+    /** The generics one symbol declares, through the alias it may be. */
+    const genericsOf = (symbol) => {
+        const target = (symbol.flags & SymbolFlags.Alias) === 0 ? symbol : queries.aliased(symbol);
+        if (target === UNANSWERED) {
+            return [];
         }
-        const declaration = project.declarationAt(resolved.declaration)?.node;
-        const byParameter = declaration === undefined
-            ? undefined
-            : generics.get(nodeKey(declaration.getSourceFile(), declaration));
-        if (byParameter === undefined) {
-            continue;
+        return target.declarations.flatMap((handle) => {
+            const node = project.declarationAt(handle)?.node;
+            const generic = node === undefined ? undefined : genericOf(node);
+            return generic === undefined ? [] : [generic];
+        });
+    };
+    /** What one site fixes for one side of a carried access. */
+    const fixedAt = (site, side, generic) => {
+        if (side.kind === "written") {
+            return { kind: "node", node: side.node };
         }
-        for (const { object, parameter } of byParameter) {
-            const fixed = queries.typeAtPosition(resolved, parameter);
-            const literal = fixed === UNANSWERED ? undefined : literalTypeNames(fixed, (type) => partsOf(type));
-            if (literal !== undefined) {
-                accesses.push({ file, from, at: call, object, names: literal });
+        const { node } = site;
+        if (side.kind === "receiver") {
+            const callee = isCallExpression(node) ? node.expression : undefined;
+            if (callee === undefined || !isPropertyAccessExpression(callee)) {
+                return undefined;
+            }
+            const receiver = queries.typeAt(callee.expression);
+            if (receiver === UNANSWERED || receiver === undefined) {
+                return undefined;
             }
+            const args = queries.typeArguments(receiver);
+            const type = args === UNANSWERED ? undefined : args[side.index];
+            return type === undefined ? undefined : { kind: "type", type };
         }
+        const written = node.typeArguments?.[side.index];
+        if (written !== undefined) {
+            const passed = namedParameter(written, site.enclosing);
+            return passed === undefined
+                ? { kind: "node", node: written }
+                : { kind: "passed", generic: passed.generic, index: passed.index };
+        }
+        if (isTypeReferenceNode(node)) {
+            return undefined;
+        }
+        const at = (generic.parameters ?? []).findIndex((parameter) => {
+            const type = parameter.type === undefined ? undefined : unwrappedType(parameter.type);
+            return (type !== undefined &&
+                isTypeReferenceNode(type) &&
+                isIdentifier(type.typeName) &&
+                parameterAt(generic, type.typeName.text) === side.index);
+        });
+        if (at < 0) {
+            return undefined;
+        }
+        const resolved = queries.resolvedSignature(node);
+        if (resolved === UNANSWERED || resolved === undefined) {
+            return undefined;
+        }
+        const type = queries.typeAtPosition(resolved, at);
+        return type === UNANSWERED ? undefined : { kind: "type", type };
+    };
+    /** Reads one carried access at one site: an access where both sides are fixed, a carry where one is passed on. */
+    const readAt = (site, generic, one) => {
+        const object = fixedAt(site, one.object, generic);
+        const index = object === undefined ? undefined : fixedAt(site, one.index, generic);
+        if (object === undefined || index === undefined) {
+            return false;
+        }
+        const passed = [object, index].find((fixed) => fixed.kind === "passed");
+        if (passed !== undefined) {
+            const side = (fixed) => fixed.kind === "passed"
+                ? fixed.generic === passed.generic
+                    ? { kind: "parameter", index: fixed.index }
+                    : undefined
+                : fixed.kind === "node"
+                    ? { kind: "written", node: fixed.node }
+                    : undefined;
+            const objectSide = side(object);
+            const indexSide = side(index);
+            return objectSide !== undefined && indexSide !== undefined
+                ? carry(passed.generic, { object: objectSide, index: indexSide })
+                : false;
+        }
+        const objectAt = concrete(object);
+        const indexAt = concrete(index);
+        if (objectAt === undefined || indexAt === undefined) {
+            return false;
+        }
+        accesses.push({
+            file: site.file,
+            from: site.from,
+            at: site.node,
+            object: objectAt,
+            index: "kind" in indexAt ? (literalNames(indexAt) ?? indexAt) : indexAt,
+        });
+        return false;
+    };
+    // A site passing a type parameter on carries the access to its own generic, so the
+    // sites are read again until no generic gains an access.
+    const resolvedGenerics = new Map();
+    const read = new Set();
+    for (let changed = true; changed;) {
+        changed = false;
+        const pending = sites.filter((site) => names.has(site.name) && !resolvedGenerics.has(site));
+        const typeSites = pending.filter((site) => isTypeReferenceNode(site.node));
+        const symbols = typeSites.length === 0
+            ? []
+            : queries.symbolsAt(typeSites.map((site) => site.node.typeName));
+        typeSites.forEach((site, at) => {
+            const symbol = symbols[at];
+            resolvedGenerics.set(site, symbol === UNANSWERED || symbol === undefined ? [] : genericsOf(symbol));
+        });
+        for (const site of pending.filter((one) => !isTypeReferenceNode(one.node))) {
+            const resolved = queries.resolvedSignature(site.node);
+            const declaration = resolved === UNANSWERED || resolved?.declaration === undefined
+                ? undefined
+                : project.declarationAt(resolved.declaration)?.node;
+            const generic = declaration === undefined ? undefined : genericOf(declaration);
+            resolvedGenerics.set(site, generic === undefined ? [] : [generic]);
+        }
+        sites.forEach((site, siteAt) => {
+            for (const generic of resolvedGenerics.get(site) ?? []) {
+                (carried.get(generic) ?? []).forEach((one, at) => {
+                    const key = `${String(siteAt)}:${String(at)}:${nodeKey(generic.getSourceFile(), generic)}`;
+                    if (read.has(key)) {
+                        return;
+                    }
+                    read.add(key);
+                    changed = readAt(site, generic, one) || changed;
+                });
+            }
+        });
     }
-    function partsOf(type) {
-        const parts = queries.constituents(type);
-        return parts === UNANSWERED ? [type] : parts;
-    }
-    const objectNodes = accesses.flatMap((one) => ("kind" in one.object ? [one.object] : []));
+    // A generic function or method declared outside the project's own files carries what
+    // its own text indexes by its type parameters and its receiver's.
+    const outside = literalCalls.filter((site) => !resolvedGenerics.has(site));
+    const methods = outside.length === 0
+        ? []
+        : queries.symbolsAt(outside.map((site) => {
+            const callee = site.node.expression;
+            return isPropertyAccessExpression(callee) ? callee.name : callee;
+        }));
+    const own = project.ownPaths();
+    outside.forEach((site, at) => {
+        const named = methods[at];
+        const symbol = named === UNANSWERED || named === undefined || (named.flags & SymbolFlags.Alias) === 0
+            ? named
+            : queries.aliased(named);
+        if (symbol === UNANSWERED ||
+            symbol === undefined ||
+            (symbol.flags & (SymbolFlags.Function | SymbolFlags.Method)) === 0) {
+            return;
+        }
+        for (const handle of symbol.declarations) {
+            if (own.has(handle.path)) {
+                continue;
+            }
+            const node = project.declarationAt(handle)?.node;
+            const generic = node === undefined ? undefined : genericOf(node);
+            if (generic === undefined) {
+                continue;
+            }
+            for (const one of carriedIn(generic)) {
+                readAt(site, generic, one);
+            }
+        }
+    });
+    const typeNodes = accesses.flatMap((one) => [
+        ...("kind" in one.object ? [one.object] : []),
+        ...(!Array.isArray(one.index) && "kind" in one.index ? [one.index] : []),
+    ]);
     const typeOf = new Map();
-    queries.typesAt(objectNodes).forEach((answer, index) => {
-        const node = objectNodes[index];
+    queries.typesAt(typeNodes).forEach((answer, index) => {
+        const node = typeNodes[index];
         if (answer !== UNANSWERED && answer !== undefined && node !== undefined) {
             typeOf.set(node, answer);
         }
     });
+    const asType = (side) => "kind" in side ? typeOf.get(side) : side;
     const found = [];
     for (const access of accesses) {
-        const type = "kind" in access.object ? typeOf.get(access.object) : access.object;
-        if (type === undefined) {
+        const type = asType(access.object);
+        const indexType = Array.isArray(access.index)
+            ? undefined
+            : asType(access.index);
+        const accessed = Array.isArray(access.index)
+            ? access.index
+            : indexType === undefined
+                ? undefined
+                : literalTypeNames(indexType, partsOf);
+        if (type === undefined || accessed === undefined) {
             continue;
         }
         const position = renderPosition(access.file, root, access.at.getStart());
@@ -148,7 +425,7 @@ export function indexedAccessReferences(project, held, chains, root, testFiles)
                 continue;
             }
             for (const property of properties) {
-                if (!access.names.includes(property.escapedName)) {
+                if (!accessed.includes(property.escapedName)) {
                     continue;
                 }
                 for (const to of chains.declarationsOf(property)) {
@@ -167,49 +444,68 @@ export function indexedAccessReferences(project, held, chains, root, testFiles)
     return found;
 }
 /**
- * Records an indexed-access type whose index names a type parameter of an enclosing
- * function that a parameter of that function is annotated with whole, so a call's
- * argument for that parameter fixes the index.
+ * The local names one file binds to a package: each name an import declaration with a
+ * bare specifier binds, and each variable initialized by a call or a construction whose
+ * callee such a name heads, read in source order.
  */
-function parameterIndex(node, enclosing, file, generics, names) {
-    const index = unwrappedType(node.indexType);
-    if (!isTypeReferenceNode(index) || !isIdentifier(index.typeName)) {
-        return;
-    }
-    const spelled = index.typeName.text;
-    for (const generic of [...enclosing].reverse()) {
-        const declares = (generic.typeParameters ?? []).some((parameter) => isIdentifier(parameter.name) && parameter.name.text === spelled);
-        if (!declares) {
+function packageBindings(file) {
+    const names = new Set();
+    for (const statement of file.statements) {
+        if (!isImportDeclaration(statement) ||
+            !isStringLiteral(statement.moduleSpecifier) ||
+            /^[./]/u.test(statement.moduleSpecifier.text)) {
             continue;
         }
-        const at = generic.parameters.findIndex((parameter) => {
-            const type = parameter.type === undefined ? undefined : unwrappedType(parameter.type);
-            return (type !== undefined &&
-                isTypeReferenceNode(type) &&
-                isIdentifier(type.typeName) &&
-                type.typeName.text === spelled);
-        });
-        if (at >= 0) {
-            const key = nodeKey(file, generic);
-            generics.set(key, [...(generics.get(key) ?? []), { object: node.objectType, parameter: at }]);
-            const name = calledName(generic);
-            if (name !== undefined) {
-                names.add(name);
-            }
+        const clause = statement.importClause;
+        if (clause?.name !== undefined) {
+            names.add(clause.name.text);
+        }
+        const bindings = clause?.namedBindings;
+        if (bindings !== undefined && isNamespaceImport(bindings)) {
+            names.add(bindings.name.text);
         }
-        return;
+        else if (bindings !== undefined && isNamedImports(bindings)) {
+            bindings.elements.forEach((element) => names.add(element.name.text));
+        }
+    }
+    if (names.size === 0) {
+        return names;
     }
+    const visit = (node) => {
+        if (isVariableDeclaration(node) &&
+            isIdentifier(node.name) &&
+            node.initializer !== undefined &&
+            (isCallExpression(node.initializer) || isNewExpression(node.initializer))) {
+            const head = rootName(node.initializer.expression);
+            if (head !== undefined && names.has(head)) {
+                names.add(node.name.text);
+            }
+        }
+        node.forEachChild(visit);
+    };
+    visit(file);
+    return names;
 }
-/** The name a call writes to call one generic function: its own, or its variable's. */
-function calledName(generic) {
-    const own = generic.name;
-    if (own !== undefined && isIdentifier(own)) {
-        return own.text;
+/** The identifier an expression is headed by, through property accesses and calls. */
+function rootName(expression) {
+    let at = expression;
+    for (;;) {
+        if (isIdentifier(at)) {
+            return at.text;
+        }
+        if (isPropertyAccessExpression(at) || isCallExpression(at) || isNewExpression(at)) {
+            at = at.expression;
+            continue;
+        }
+        if (isParenthesizedExpression(at) || isNonNullExpression(at)) {
+            at = at.expression;
+            continue;
+        }
+        return undefined;
     }
-    const parent = generic.parent;
-    return parent.kind === SyntaxKind.VariableDeclaration &&
-        parent.name !== undefined &&
-        isIdentifier(parent.name)
-        ? parent.name.text
-        : undefined;
+}
+/** What makes two carried accesses one: the kind and position of each side, or its written node. */
+function sideKey(one) {
+    const key = (side) => side.kind === "written" ? ["written", side.node.pos, side.node.end] : [side.kind, side.index];
+    return [key(one.object), key(one.index)];
 }