@cplieger/deadset-ts 7.0.0-dev.1 → 7.0.0-dev.3

package/dist/src/unimplemented-callees.js

@@ -0,0 +1,312 @@
+/**
+ * The members read where code the target cannot see receives a value of a target type. An
+ * object literal argument of a call or a `new` whose callee has no implementation in the
+ * target has every member of the parameter type it is checked against read, nested
+ * literals included. An `as` expression over an object no file of the project declares, and
+ * a `new` through an unimplemented construct signature, hand the target a value the
+ * outside code holds, so every member of the type it is given is read.
+ */
+import { isArrowFunction, isAsExpression, isCallExpression, isClassDeclaration, isClassExpression, isFunctionDeclaration, isFunctionExpression, isHeritageClause, isIdentifier, isMethodDeclaration, isNewExpression, isObjectLiteralExpression, isParameterDeclaration, isParenthesizedExpression, isPropertyAccessExpression, isPropertyAssignment, isPropertyDeclaration, isSatisfiesExpression, isTypeReferenceNode, 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";
+/** The value an `as` expression asserts a type of, through every `as` and parenthesis around it. */
+function castOperand(node) {
+    let at = node;
+    while (isAsExpression(at) || isParenthesizedExpression(at)) {
+        at = at.expression;
+    }
+    return at;
+}
+/** Whether a declaration node carries a body of statements or an expression. */
+function hasBody(node) {
+    return node.body !== undefined;
+}
+function isFunctionLike(node) {
+    return (node !== undefined &&
+        (isArrowFunction(node) ||
+            isFunctionExpression(node) ||
+            isFunctionDeclaration(node) ||
+            isClassExpression(node)));
+}
+/** The name a declaration is declared under, where it has one an identifier spells. */
+function nameOf(node) {
+    const name = node.name;
+    return name !== undefined && isIdentifier(name) ? name.text : undefined;
+}
+/**
+ * Whether an overload signature has its implementation beside it: a declaration of the same
+ * name and kind, in the same statement list or class body, that carries a body.
+ */
+function overloadImplemented(node) {
+    if (!isFunctionDeclaration(node) && !isMethodDeclaration(node)) {
+        return false;
+    }
+    const name = nameOf(node);
+    let implemented = false;
+    node.parent.forEachChild((sibling) => {
+        implemented ||= sibling.kind === node.kind && nameOf(sibling) === name && hasBody(sibling);
+    });
+    return implemented;
+}
+/** Every object literal one argument holds, the argument itself included, through nested property values. */
+function literalsOf(argument) {
+    if (!isObjectLiteralExpression(argument)) {
+        return [];
+    }
+    return [
+        argument,
+        ...argument.properties.flatMap((property) => isPropertyAssignment(property) ? literalsOf(property.initializer) : []),
+    ];
+}
+/**
+ * The reads the object-literal arguments of one project's own files make of the members of
+ * the types they are checked against, where the callee has no implementation in the target.
+ */
+export function unimplementedCalleeReads(project, held, chains, root, testFiles) {
+    const queries = project.queries;
+    const own = project.ownPaths();
+    const passing = [];
+    const implementing = [];
+    const asserted = [];
+    const constructed = [];
+    const handing = [];
+    for (const file of project.ownSourceFiles()) {
+        const fileId = held.declarations.get(nodeKey(file, file));
+        if (fileId === undefined) {
+            continue;
+        }
+        const visit = (node, from) => {
+            const holder = held.declarations.get(nodeKey(file, node)) ?? from;
+            if ((isCallExpression(node) || isNewExpression(node)) &&
+                (node.arguments ?? []).some((argument) => isObjectLiteralExpression(argument))) {
+                passing.push({ file, from: holder, call: node });
+            }
+            if (isNewExpression(node)) {
+                constructed.push({ file, from: holder, call: node });
+            }
+            if ((isCallExpression(node) || isNewExpression(node)) &&
+                (node.arguments ?? []).some((argument) => isFunctionLike(argument) || isIdentifier(argument))) {
+                handing.push(node);
+            }
+            if (isAsExpression(node) && !isAsExpression(node.parent)) {
+                asserted.push({ file, from: holder, node, operand: castOperand(node) });
+            }
+            if (isClassDeclaration(node) || isClassExpression(node)) {
+                for (const clause of node.heritageClauses ?? []) {
+                    if (isHeritageClause(clause)) {
+                        implementing.push(...clause.types.map((one) => isTypeReferenceNode(one) ? one.typeName : one.expression));
+                    }
+                }
+            }
+            // An object literal typed as an interface implements that interface's methods.
+            if (isVariableDeclaration(node) &&
+                node.type !== undefined &&
+                isTypeReferenceNode(node.type) &&
+                node.initializer !== undefined &&
+                isObjectLiteralExpression(node.initializer)) {
+                implementing.push(node.type.typeName);
+            }
+            if ((isSatisfiesExpression(node) || isAsExpression(node)) &&
+                isObjectLiteralExpression(node.expression) &&
+                isTypeReferenceNode(node.type)) {
+                implementing.push(node.type.typeName);
+            }
+            node.forEachChild((child) => {
+                visit(child, holder);
+            });
+        };
+        file.forEachChild((child) => {
+            visit(child, fileId);
+        });
+    }
+    if (passing.length === 0 && asserted.length === 0 && constructed.length === 0) {
+        return [];
+    }
+    const resolved = (symbol) => {
+        if (symbol === UNANSWERED || symbol === undefined) {
+            return undefined;
+        }
+        if ((symbol.flags & SymbolFlags.Alias) === 0) {
+            return symbol;
+        }
+        const target = queries.aliased(symbol);
+        return target === UNANSWERED ? undefined : target;
+    };
+    const declarationsOf = (symbol) => (symbol?.declarations ?? []).flatMap((handle) => {
+        const node = project.declarationAt(handle)?.node;
+        return node === undefined ? [] : [node];
+    });
+    const implemented = new Set(queries.symbolsAt(implementing).flatMap((symbol) => declarationsOf(resolved(symbol))));
+    /** Whether a declaration is a function or a class of the target, or a variable or property it initializes. */
+    const ownFunction = (node) => own.has(node.getSourceFile().fileName) &&
+        (isFunctionLike(node) ||
+            ((isVariableDeclaration(node) || isPropertyAssignment(node) || isPropertyDeclaration(node)) &&
+                isFunctionLike(node.initializer)));
+    /**
+     * Whether a function or a class of the target reaches one parameter of a function of the
+     * target, passed for it by a call that names the function. A call through another name
+     * is not followed, so its callee keeps no implementation and its literal reads more.
+     */
+    const reachedParameters = new Map();
+    const parameterReached = (parameter) => {
+        const known = reachedParameters.get(parameter);
+        if (known !== undefined) {
+            return known;
+        }
+        const fn = parameter.parent;
+        const fnName = nameOf(fn) ?? (isVariableDeclaration(fn.parent) ? nameOf(fn.parent) : undefined);
+        const at = fn.parameters?.indexOf(parameter) ?? -1;
+        const passed = handing.flatMap((call) => {
+            const callee = call.expression;
+            const name = isPropertyAccessExpression(callee) ? callee.name : callee;
+            if (fnName === undefined || !isIdentifier(name) || name.text !== fnName) {
+                return [];
+            }
+            const signature = queries.resolvedSignature(call);
+            const handle = signature === UNANSWERED || signature === undefined ? undefined : signature.declaration;
+            const argument = handle === undefined || project.declarationAt(handle)?.node !== fn
+                ? undefined
+                : (call.arguments ?? [])[at];
+            return argument === undefined || at < 0 ? [] : [argument];
+        });
+        const named = passed.filter((argument) => isIdentifier(argument));
+        const reached = passed.some((argument) => isFunctionLike(argument)) ||
+            queries
+                .symbolsAt(named)
+                .some((symbol) => declarationsOf(resolved(symbol)).some((node) => ownFunction(node)));
+        reachedParameters.set(parameter, reached);
+        return reached;
+    };
+    /** Whether some function, class or object literal of the target stands for a signature. */
+    const standsFor = (passed) => {
+        const signature = queries.resolvedSignature(passed.call);
+        const handle = signature === UNANSWERED || signature === undefined ? undefined : signature.declaration;
+        const declaration = handle === undefined ? undefined : project.declarationAt(handle)?.node;
+        if (declaration === undefined) {
+            return true;
+        }
+        if (hasBody(declaration) || overloadImplemented(declaration)) {
+            return own.has(handle?.path ?? "");
+        }
+        const holder = declaration.parent;
+        if (holder !== undefined && implemented.has(holder)) {
+            return true;
+        }
+        const callee = passed.call.expression;
+        const name = isPropertyAccessExpression(callee) ? callee.name : callee;
+        const [named] = queries.symbolsAt([name]);
+        return declarationsOf(resolved(named)).some((node) => isParameterDeclaration(node)
+            ? own.has(node.getSourceFile().fileName) && parameterReached(node)
+            : ownFunction(node) && !isFunctionLike(node));
+    };
+    const literals = [];
+    for (const passed of passing) {
+        if (standsFor(passed)) {
+            continue;
+        }
+        for (const argument of passed.call.arguments ?? []) {
+            literals.push(...literalsOf(argument).map((literal) => ({ passed, literal })));
+        }
+    }
+    const contexts = queries.contextualTypes(literals.map((one) => one.literal));
+    const found = [];
+    literals.forEach(({ passed, literal }, at) => {
+        const context = contexts[at];
+        if (context === UNANSWERED || context === undefined) {
+            return;
+        }
+        const parts = queries.constituents(context);
+        const position = renderPosition(passed.file, root, literal.getStart());
+        for (const part of parts === UNANSWERED ? [context] : parts) {
+            const properties = queries.propertiesOf(part);
+            for (const property of properties === UNANSWERED ? [] : properties) {
+                for (const to of chains.declarationsOf(property)) {
+                    found.push({
+                        from: passed.from,
+                        to,
+                        position,
+                        use: "read",
+                        resolution: "contextual",
+                        test: testFiles.has(position.path),
+                    });
+                }
+            }
+        }
+    });
+    found.push(...handedOver());
+    return found;
+    /** Whether a type is an object no file of the project declares, a platform object's among them. */
+    function outsideValue(type) {
+        if (!type.isObjectType()) {
+            return false;
+        }
+        const symbol = queries.symbolOfType(type);
+        const declared = symbol === UNANSWERED ? undefined : symbol;
+        return declared?.declarations.every((handle) => !own.has(handle.path)) === true;
+    }
+    /** Whether a type is an object type a file of the project declares. */
+    function ownObject(type) {
+        const known = type === UNANSWERED ? undefined : type;
+        if (!known?.isObjectType()) {
+            return false;
+        }
+        const symbol = queries.symbolOfType(known);
+        const declared = symbol === UNANSWERED ? undefined : symbol;
+        return declared?.declarations.some((handle) => own.has(handle.path)) === true;
+    }
+    /** The reads of every member of each target type an outside value is handed over as. */
+    function handedOver() {
+        const operandTypes = queries.typesAt(asserted.map((one) => one.operand));
+        const fromCasts = asserted.filter((_one, at) => {
+            const type = operandTypes[at];
+            return type !== UNANSWERED && type !== undefined && outsideValue(type);
+        });
+        const newTypes = queries.typesAt(constructed.map((one) => one.call));
+        // A construct signature whose declared result is one of its type parameters names no
+        // type the target declares, so only a result the signature itself names is handed over.
+        const fromConstructors = constructed
+            .filter((one, at) => {
+            if (!ownObject(newTypes[at]) || standsFor(one)) {
+                return false;
+            }
+            const signature = queries.resolvedSignature(one.call);
+            const result = signature === UNANSWERED || signature === undefined
+                ? undefined
+                : queries.returnTypeOf(signature);
+            return result !== UNANSWERED && result !== undefined && !result.isTypeParameter();
+        })
+            .map((one) => ({ file: one.file, from: one.from, node: one.call }));
+        const handed = [...fromCasts, ...fromConstructors];
+        const types = queries.typesAt(handed.map((one) => one.node));
+        const reads = [];
+        handed.forEach((one, at) => {
+            const type = types[at];
+            if (type === UNANSWERED || type === undefined) {
+                return;
+            }
+            const position = renderPosition(one.file, root, one.node.getStart());
+            const parts = queries.constituents(type);
+            for (const part of parts === UNANSWERED ? [type] : parts) {
+                if (!ownObject(part)) {
+                    continue;
+                }
+                const properties = queries.propertiesOf(part);
+                for (const property of properties === UNANSWERED ? [] : properties) {
+                    for (const to of chains.declarationsOf(property)) {
+                        reads.push({
+                            from: one.from,
+                            to,
+                            position,
+                            use: "read",
+                            resolution: "contextual",
+                            test: testFiles.has(position.path),
+                        });
+                    }
+                }
+            }
+        });
+        return reads;
+    }
+}

package/dist/src/value-reach.js

@@ -1,11 +1,10 @@
 /**
  * The classes of the target a value of one type carries, and the members of the other
- * object types the target writes that it carries, as a serializer walking the value
- * reaches them: through union and intersection constituents, array and tuple elements,
- * and the data members and index signatures of the target's classes and of the
- * interfaces and object types the target writes. The walk stops at `any`, `unknown`, a
- * type parameter, a function and an interface or class of another program, so an
- * instance held only there is missed.
+ * object types the target writes that it carries, as a serializer walking the value reaches
+ * them: through constituents, array and tuple elements, the data members and index
+ * signatures of the types the target writes, and the values `stored` gives for a type where
+ * it erases them. The walk stops at `any`, `unknown`, a type parameter, a function and an
+ * interface or class of another program, so an instance held only there is missed.
  */
 import { ObjectFlags, SymbolFlags, } from "@typescript/native/unstable/sync";
 import { classNames, typesAt } from "./class-members.js";
@@ -28,7 +27,7 @@ function arrayTargets(project) {
  * The walk over one project's types, against the classes of `held`, the same
  * project's inventory.
  */
-export function valueReach(project, held) {
+export function valueReach(project, held, stored = () => []) {
     const queries = project.queries;
     const names = [...classNames(project, held)];
     const declared = typesAt(project, names.map(([, node]) => node));
@@ -110,6 +109,7 @@ export function valueReach(project, held) {
                 found = must(queries.typeArguments(type));
             }
         }
+        found = [...found, ...stored(type)];
         children.set(type.id, found);
         return found;
     };

package/dist/src/verbs/analyze.js

@@ -10,7 +10,7 @@ import { json } from "../reporters/json.js";
 import { RENDERINGS } from "../reporters/reporters.js";
 import { parseTemplate, TemplateError } from "../reporters/template.js";
 import { resolve } from "../resolve.js";
-import { rowReason, writeBaseline } from "../suppress-file.js";
+import { otherSchemeRows, rowReason, writeBaseline } from "../suppress-file.js";
 import { CONTRACT_VERSION } from "../version.js";
 import { EXIT_CLEAN, EXIT_FAILURE } from "./verb.js";
 /** The options `analyze` takes beside the ones every verb takes. */
@@ -116,13 +116,12 @@ function templateOf(host, invoked, named, formats) {
     }
 }
 /**
- * Analyzes the scope under the configuration and writes the JSON report to the path
- * `--report` names, each rendering `--format` names beside it at the report's path with the
- * format's suffix appended, and where `--baseline-write` names a path the baseline a fixpoint
- * over the analysis records, the report then being its first round, which reads no
- * baseline. The template format renders the template `--template` names. Nothing is written to
- * the output stream; diagnostics go to the error stream and the verdict is the exit code, or 0
- * under `--exit-code=off`, and a rendering that cannot be written ends the run with 3.
+ * Analyzes the scope and writes the JSON report to the path `--report` names, each
+ * `--format` rendering beside it with the format's suffix appended, and under
+ * `--baseline-write` the baseline a fixpoint over the analysis records, the report being its
+ * first round. Diagnostics go to the error stream and nothing to the output stream; the
+ * verdict is the exit code, or 0 under `--exit-code=off`, and a rendering that cannot be
+ * written ends the run with 3.
  */
 export const analyzeVerb = ({ err, host, inputs, scope, openClient, option, repeated }) => {
     const reportPath = option("report");
@@ -227,7 +226,10 @@ export const analyzeVerb = ({ err, host, inputs, scope, openClient, option, repe
             }
         }
         if (documents.baseline !== undefined) {
-            host.writeDocument(documents.baseline, writeBaseline(recorded, analyzerProvenance(version)));
+            const kept = host.kindOf(documents.baseline) === "file"
+                ? otherSchemeRows(host.readFile(documents.baseline))
+                : [];
+            host.writeDocument(documents.baseline, writeBaseline(recorded, analyzerProvenance(version), kept));
         }
     }
     catch (error) {

package/dist/src/workspace-programs.js

@@ -205,8 +205,6 @@ function scan(engine, program, reading, resolver) {
             reading.unresolved.push({
                 file: usage.file,
                 specifier,
-                member: answer.member,
-                subpath: answer.subpath,
                 reason: answer.reason,
             });
         }
@@ -309,7 +307,6 @@ export function workspacePrograms(engine, host, configFiles, resolver) {
         readings: readings.map((reading) => ({
             configFile: reading.configFile,
             fileNames: reading.parsed.fileNames,
-            entries: reading.entries,
             unresolved: reading.unresolved,
             componentsUnread: unread.get(reading.configFile),
         })),

package/dist/src/workspace-resolution.js

@@ -259,7 +259,6 @@ export function workspaceResolver(host, workspace) {
                 return {
                     kind: "unresolved",
                     member: name,
-                    subpath,
                     reason: `${String(linked.dirs.length)} workspace packages are named ${name} (${linked.dirs.join(", ")}) and nothing links the importer to one of them; install the workspace, or declare the dependency with a range only one of them satisfies`,
                 };
             }
@@ -295,7 +294,6 @@ export function workspaceResolver(host, workspace) {
             return {
                 kind: "unresolved",
                 member: name,
-                subpath,
                 reason: built
                     ? `its manifest names ${named}, output no tsconfig*.json of the package maps back to source, and nothing installed links the importer to it; install the workspace, or point an exports condition the importing configuration's customConditions lists at its source`
                     : member.configurations.length === 0

package/dist/src/workspace.js

@@ -256,7 +256,6 @@ function configurationsOf(host, dir, parse) {
             ? []
             : [
                 {
-                    configFile,
                     fileNames: new Set(parsed.fileNames),
                     layout: layoutOf(configFile, parsed),
                 },
@@ -338,8 +337,6 @@ export function findWorkspace(host, targetRoot, parse) {
         return found;
     };
     return {
-        root: declared.root,
-        declaredIn: declared.file,
         members,
         named,
         memberOf: (path) => {

package/jsr.json

@@ -1,6 +1,6 @@
 {
   "name": "@cplieger/deadset-ts",
-  "version": "7.0.0-dev.1",
+  "version": "7.0.0-dev.3",
   "license": "GPL-3.0-or-later",
   "exports": {
     ".": "./src/index.ts"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cplieger/deadset-ts",
-  "version": "7.0.0-dev.1",
+  "version": "7.0.0-dev.3",
   "type": "module",
   "sideEffects": false,
   "description": "Deterministic dead-code analysis for TypeScript, class and type members included",
@@ -24,6 +24,7 @@
     "typecheck:tests": "tsc -p tsconfig.test.json",
     "test": "vitest --run",
     "test:starters": "vitest --run --config starters/vitest.config.ts",
+    "test:mutation": "stryker run",
     "lint": "eslint .",
     "lint:prettier": "prettier --check .",
     "lint:fix": "eslint . --fix && prettier --write ."
@@ -44,7 +45,7 @@
     "fast-check": "4.10.2",
     "prettier": "3.9.9",
     "typescript": "npm:@typescript/typescript6@6.0.2",
-    "typescript-eslint": "8.71.0",
+    "typescript-eslint": "8.71.1",
     "vitest": "5.0.3"
   },
   "publishConfig": {