@cplieger/deadset-ts 8.0.0-dev.2 → 8.0.0-dev.20

package/dist/src/calls.js

@@ -1,14 +1,15 @@
 /**
  * The calls and decorators of one project that the configured classes read: what each
  * callee resolves to, and which of the target's classes a call passes or a decorator
- * is attached to. A class is passed as an argument, or as an element of an array
- * literal or a property value of an object literal written as one, at any depth, and a
+ * is attached to. A class is passed by each value an argument can be, at any depth inside
+ * the array and object literals it writes, named directly or through variables, and a
  * decorator written as a call is a call.
  */
-import { isArrayLiteralExpression, isCallExpression, isClassDeclaration, isDecorator, isIdentifier, isObjectLiteralExpression, isParenthesizedExpression, isPropertyAccessExpression, isPropertyAssignment, isShorthandPropertyAssignment, isSpreadElement, } from "@typescript/native/ast";
-import { SymbolFlags } from "@typescript/native/sync";
+import { isArrayLiteralExpression, isArrowFunction, isBinaryExpression, isBindingElement, isCallExpression, isClassDeclaration, isConditionalExpression, isDecorator, isFunctionDeclaration, isFunctionExpression, isIdentifier, isMethodDeclaration, isObjectLiteralExpression, isParameterDeclaration, isParenthesizedExpression, isPropertyAccessExpression, isPropertyAssignment, isPropertyDeclaration, isShorthandPropertyAssignment, isOmittedExpression, isSpreadAssignment, isSpreadElement, isVariableDeclaration, SyntaxKind, } from "@typescript/native/ast";
+import { ObjectFlags, SymbolFlags, } from "@typescript/native/sync";
 import { nodeKey } from "./inventory.js";
 import { must } from "./query.js";
+import { unwrapped } from "./unwrap.js";
 /** The name node a callee or a decorator expression resolves through, where it has one. */
 export function calleeName(expression) {
     if (isParenthesizedExpression(expression)) {
@@ -65,61 +66,296 @@ export function resolvedTargets(project, nodes) {
     });
     return targets;
 }
-/** The values one expression passes: itself, or what an array or object literal holds. */
-function passedIn(expression, found) {
-    if (isParenthesizedExpression(expression)) {
-        passedIn(expression.expression, found);
-        return;
-    }
-    if (isArrayLiteralExpression(expression)) {
-        for (const element of expression.elements) {
-            passedIn(isSpreadElement(element) ? element.expression : element, found);
-        }
-        return;
+/** The declaration a shorthand property's value resolves to, an import followed to what it names. */
+function shorthandTarget(project, node) {
+    const value = must(project.shorthandValueAt(project.handle(node)));
+    if (value === undefined || (value.flags & SymbolFlags.Alias) === 0) {
+        return value;
     }
-    if (isObjectLiteralExpression(expression)) {
-        for (const property of expression.properties) {
-            if (isPropertyAssignment(property)) {
-                passedIn(property.initializer, found);
+    const aliased = must(project.queries.aliased(value));
+    return aliased.declarations.length === 0 ? undefined : aliased;
+}
+/**
+ * The values one expression passes: each value it can be ({@link leavesOf}), or what an
+ * array or object literal it can be holds, at any depth.
+ */
+function passedIn(written, found) {
+    for (const expression of leavesOf(written)) {
+        if (isArrayLiteralExpression(expression)) {
+            for (const element of expression.elements) {
+                passedIn(element, found);
             }
-            else if (isShorthandPropertyAssignment(property)) {
-                found.push({ site: property.name, name: property, shorthand: true });
+        }
+        else if (isObjectLiteralExpression(expression)) {
+            for (const property of expression.properties) {
+                if (isPropertyAssignment(property)) {
+                    passedIn(property.initializer, found);
+                }
+                else if (isSpreadAssignment(property)) {
+                    passedIn(property.expression, found);
+                }
+                else if (isShorthandPropertyAssignment(property)) {
+                    found.push({ site: property.name, name: property, shorthand: true });
+                }
             }
         }
-        return;
+        else if (!isOmittedExpression(expression)) {
+            found.push({ site: expression, name: calleeName(expression), shorthand: false });
+        }
     }
-    const name = calleeName(expression);
-    if (name !== undefined) {
-        found.push({ site: expression, name, shorthand: false });
+}
+/** The operators whose value is one of their operands. */
+const CHOOSING = new Set([
+    SyntaxKind.QuestionQuestionToken,
+    SyntaxKind.BarBarToken,
+    SyntaxKind.AmpersandAmpersandToken,
+]);
+/**
+ * The expressions one value can be: itself, or each branch of a conditional, each operand
+ * of `??`, `||` and `&&` and the last of a comma, inside any wrapper that changes no value.
+ * Each is read alone because the checker reduces a union by subtype, so the type at the
+ * whole drops a class structurally equal to, or a subtype of, another branch's.
+ */
+function leavesOf(written) {
+    const expression = unwrapped(isSpreadElement(written) ? written.expression : written);
+    if (isConditionalExpression(expression)) {
+        return [...leavesOf(expression.whenTrue), ...leavesOf(expression.whenFalse)];
     }
+    if (isBinaryExpression(expression)) {
+        const operator = expression.operatorToken.kind;
+        if (CHOOSING.has(operator)) {
+            return [...leavesOf(expression.left), ...leavesOf(expression.right)];
+        }
+        if (operator === SyntaxKind.CommaToken) {
+            return leavesOf(expression.right);
+        }
+    }
+    return [expression];
 }
 /** The values one argument passes, a spread argument's included. */
-export function valuesPassed(argument) {
+function leavesPassed(argument) {
     const found = [];
-    passedIn(isSpreadElement(argument) ? argument.expression : argument, found);
+    passedIn(argument, found);
     return found;
 }
+/** The values one argument passes that name their declaration. */
+export function valuesPassed(argument) {
+    return leavesPassed(argument).filter((value) => value.name !== undefined);
+}
 /**
- * The classes of the target each call passes, by the call. A value that names no
- * class of the target, a class of another program included, passes nothing here.
+ * What one passed value holds: the declaration its name resolves to, and the classes and
+ * functions the checker's type at it holds ({@link constructedAt}). `known` holds names
+ * already resolved in a batch.
+ */
+function heldBy(project, value, known) {
+    const { name } = value;
+    if (name === undefined) {
+        return { named: undefined, typed: constructedAt(project, value.site) };
+    }
+    if (value.shorthand) {
+        return { named: shorthandTarget(project, name), typed: [] };
+    }
+    return {
+        named: known?.get(name) ?? resolvedTargets(project, [name]).get(name),
+        typed: constructedAt(project, value.site),
+    };
+}
+/**
+ * The classes of the target each call passes, by the call: each class a value an argument
+ * can be holds as a constructor, as the checker types it. A name whose type erases the
+ * class is followed through what its declaration binds ({@link boundTo}) and, for a
+ * parameter, through what each call of its function passes at its place, so a class handed
+ * to a wrapper is passed. A class is used at each value that passes it. A class of another
+ * program passes nothing.
  */
 export function classesPassed(project, held, chains, calls) {
-    const passed = new Map(calls.map((call) => [call, call.arguments.flatMap((argument) => valuesPassed(argument))]));
-    const all = [...passed.values()].flat();
-    const targets = resolvedTargets(project, all.filter((value) => !value.shorthand).map((value) => value.name));
+    const passed = new Map(calls.map((call) => [call, call.arguments.flatMap(leavesPassed)]));
+    const targets = resolvedTargets(project, [...passed.values()].flat().flatMap((value) => (value.shorthand ? [] : (value.name ?? []))));
     const classes = new Set(held.symbols.filter((symbol) => symbol.kind === "class").map((symbol) => symbol.id));
-    const classesOf = (value) => {
-        const symbol = value.shorthand
-            ? must(project.shorthandValueAt(project.handle(value.name)))
-            : targets.get(value.name);
-        return symbol === undefined
-            ? []
-            : chains.declarationsOf(symbol).filter((id) => classes.has(id));
+    let calling;
+    const callsOfFunction = (symbol) => {
+        calling ??= callsByDeclaration(project);
+        return symbol.declarations.flatMap((handle) => calling?.get(keyOf(handle)) ?? []);
+    };
+    const classesOf = (value, seen) => {
+        const { named, typed } = heldBy(project, value, targets);
+        return [
+            ...typed.flatMap((symbol) => chains.declarationsOf(symbol).filter((id) => classes.has(id))),
+            ...(named === undefined ? [] : reached(named, seen)),
+        ];
+    };
+    const reached = (symbol, seen) => {
+        const ids = chains.declarationsOf(symbol).filter((id) => classes.has(id));
+        if (ids.length > 0 || seen.has(symbol.id)) {
+            return ids;
+        }
+        seen.add(symbol.id);
+        const through = (written) => leavesPassed(written).flatMap((value) => classesOf(value, seen));
+        return symbol.declarations.flatMap((handle) => {
+            const node = project.declarationAt(handle)?.node;
+            if (node === undefined) {
+                return [];
+            }
+            if (isParameterDeclaration(node)) {
+                return argumentsAt(project, node, callsOfFunction).flatMap(through);
+            }
+            const bound = boundTo(project, node);
+            return [
+                ...(bound.written === undefined ? [] : through(bound.written)),
+                ...bound.symbols.flatMap((next) => reached(next, seen)),
+            ];
+        });
     };
-    return new Map([...passed].map(([call, values]) => [
-        call,
-        values.flatMap((value) => classesOf(value).map((id) => ({ id, site: value.site }))),
-    ]));
+    return new Map([...passed].map(([call, values]) => {
+        const uses = new Map();
+        for (const value of values) {
+            for (const id of classesOf(value, new Set())) {
+                uses.set(`${id}\u0000${String(value.site.pos)}`, { id, site: value.site });
+            }
+        }
+        return [call, [...uses.values()]];
+    }));
+}
+/**
+ * The symbols of the classes and functions the checker's type at one expression holds as
+ * values, each member of a union: the static side of a class or a function is an
+ * anonymous type its declaration's symbol names, which an instance's type is not.
+ */
+function constructedAt(project, written) {
+    return heldIn(project, must(project.queries.typeAt(unwrapped(written))));
+}
+/** The classes and functions one type holds as values, as {@link constructedAt} reads them. */
+function heldIn(project, type) {
+    const { queries } = project;
+    return (type === undefined ? [] : must(queries.constituents(type))).flatMap((part) => {
+        if (!part.isObjectType() || (part.objectFlags & ObjectFlags.Anonymous) === 0) {
+            return [];
+        }
+        return must(queries.symbolOfType(part)) ?? [];
+    });
+}
+/**
+ * What a variable, a property or a destructured binding binds its name to: a variable's
+ * or a property's initializer, the value a shorthand property names, or the property of
+ * the destructured value a binding element reads.
+ */
+function boundTo(project, node) {
+    if (isShorthandPropertyAssignment(node)) {
+        const value = shorthandTarget(project, node);
+        return { symbols: value === undefined ? [] : [value] };
+    }
+    if (isBindingElement(node)) {
+        const key = node.propertyName ?? node.name;
+        if (key === undefined || !isIdentifier(key)) {
+            return { symbols: [] };
+        }
+        const source = must(project.queries.typeAt(node.parent));
+        const property = source === undefined
+            ? undefined
+            : must(project.queries.propertiesOf(source)).find((one) => one.name === key.text);
+        return { symbols: property === undefined ? [] : [property] };
+    }
+    const written = initializerOf(node);
+    return written === undefined ? { symbols: [] } : { written, symbols: [] };
+}
+/** The value a variable or a property declaration binds its name to, where it writes one. */
+function initializerOf(node) {
+    return isVariableDeclaration(node) || isPropertyAssignment(node) || isPropertyDeclaration(node)
+        ? node.initializer
+        : undefined;
+}
+/** The key of one declaration a symbol names, the same for each symbol the checker makes of it. */
+function keyOf(handle) {
+    return `${handle.path}#${String(handle.index)}`;
+}
+/**
+ * Every call of the project by the declarations its callee can be: the function or the
+ * method it names, or else each function the checker's type at it holds, wherever that
+ * value came from. A name is also followed through what its binding copies
+ * ({@link boundTo}), which is how a call reaches a function an annotation erases.
+ * Only the target's own declarations are keys, as only its own functions are asked for.
+ */
+function callsByDeclaration(project) {
+    const calls = callsOf(project);
+    const own = project.ownPaths();
+    const callees = resolvedTargets(project, calls.flatMap((call) => calleeName(call.expression) ?? []));
+    const named = new Map();
+    const keysOf = (symbol, seen) => {
+        const known = named.get(symbol.id);
+        if (known !== undefined || seen.has(symbol.id)) {
+            return known ?? [];
+        }
+        seen.add(symbol.id);
+        const keys = symbol.declarations
+            .filter((handle) => own.has(handle.path))
+            .flatMap((handle) => {
+            const node = project.declarationAt(handle)?.node;
+            const bound = node === undefined ? { symbols: [] } : boundTo(project, node);
+            const copied = [
+                ...bound.symbols,
+                ...(bound.written === undefined ? [] : leavesPassed(bound.written)).flatMap((value) => {
+                    const { named: next, typed } = heldBy(project, value);
+                    return [...typed, ...(next === undefined ? [] : [next])];
+                }),
+            ];
+            return [keyOf(handle), ...copied.flatMap((next) => keysOf(next, seen))];
+        });
+        named.set(symbol.id, keys);
+        return keys;
+    };
+    const calleeOf = (call) => {
+        const name = calleeName(call.expression);
+        return name === undefined ? undefined : callees.get(name);
+    };
+    const declared = (call) => ((calleeOf(call)?.flags ?? 0) & (SymbolFlags.Function | SymbolFlags.Method)) !== 0;
+    const typed = calls.filter((call) => !declared(call));
+    const types = new Map(project.queries
+        .typesAt(typed.map((call) => unwrapped(call.expression)))
+        .map((type, index) => [typed[index], must(type)]));
+    const found = new Map();
+    for (const call of calls) {
+        const callee = calleeOf(call);
+        const held = [
+            ...(callee === undefined ? [] : [callee]),
+            ...(types.has(call) ? heldIn(project, types.get(call)) : []),
+        ];
+        for (const key of new Set(held.flatMap((symbol) => keysOf(symbol, new Set())))) {
+            found.set(key, [...(found.get(key) ?? []), call]);
+        }
+    }
+    return found;
+}
+/**
+ * What each call of the function a parameter belongs to passes at the parameter's place,
+ * every argument from there on for a rest parameter. The function is the one the checker's
+ * type at its own declaration names, so a function with no name of its own is called too.
+ * A `this` parameter takes no place, and an argument at or after a spread argument passes
+ * at every place the spread's length can move it to.
+ */
+function argumentsAt(project, parameter, callsOfFunction) {
+    const owner = parameter.parent;
+    if (!isFunctionDeclaration(owner) &&
+        !isMethodDeclaration(owner) &&
+        !isArrowFunction(owner) &&
+        !isFunctionExpression(owner)) {
+        return [];
+    }
+    const calls = new Set(constructedAt(project, owner).flatMap(callsOfFunction));
+    const [first] = owner.parameters;
+    const erased = first !== undefined && isIdentifier(first.name) && first.name.text === "this";
+    const place = owner.parameters.indexOf(parameter) - (erased ? 1 : 0);
+    const rest = parameter.dotDotDotToken !== undefined;
+    return [...calls].flatMap((call) => {
+        let spreads = 0;
+        return call.arguments.flatMap((argument, index) => {
+            const spread = isSpreadElement(argument);
+            const earliest = index - spreads;
+            spreads += spread ? 1 : 0;
+            const open = spread || earliest < index;
+            const lands = open ? rest || earliest <= place : rest ? index >= place : index === place;
+            return lands ? [spread ? argument.expression : argument] : [];
+        });
+    });
 }
 /** Every class declaration of the target that carries a decorator. */
 export function decoratedClasses(project, held) {