@cplieger/deadset-ts 3.12.1 → 3.13.0

package/dist/src/intra-function-parts.js

@@ -0,0 +1,643 @@
+/**
+ * The parts of the declarations one project's own files hold, read while the project's
+ * view is open: each parameter and whether its function reads it, each result and the
+ * call sites that use or discard it, each statement control flow cannot reach, each
+ * write to a local that no read reaches, and each case an earlier case covers.
+ */
+import { isArrowFunction, isAwaitExpression, isBigIntLiteral, isBinaryExpression, isBlock, isBreakStatement, isCallExpression, isCaseClause, isClassDeclaration, isClassExpression, isContinueStatement, isDecorator, isDefaultClause, isEmptyStatement, isExportAssignment, isExportSpecifier, isExpressionStatement, isFunctionDeclaration, isHeritageClause, isIdentifier, isIfStatement, isImportClause, isImportSpecifier, isInterfaceDeclaration, isMethodDeclaration, isModuleDeclaration, isNamespaceImport, isNoSubstitutionTemplateLiteral, isNumericLiteral, isParenthesizedExpression, isPrefixUnaryExpression, isPropertyAccessExpression, isReturnStatement, isShorthandPropertyAssignment, isStringLiteral, isSwitchStatement, isThrowStatement, isTypeAliasDeclaration, isVariableStatement, isVoidExpression, NodeFlags, SyntaxKind, } from "@typescript/native/unstable/ast";
+import { nodeKey } from "./inventory.js";
+import { positionKey, renderPosition } from "./position.js";
+import { DEFAULT_BATCH_CAP } from "./references.js";
+import { signatureOf } from "./signatures.js";
+/** The codes of the parts this module reads. */
+export const UNUSED_PARAMETER = "DS1801";
+export const UNUSED_RESULT = "DS1803";
+const UNREACHABLE_STATEMENT = "DS1805";
+const DEAD_STORE = "DS1807";
+const UNREACHABLE_CASE = "DS1809";
+/** The result types that carry no value, as the checker spells them. */
+const NO_VALUE = new Set([
+    "void",
+    "undefined",
+    "never",
+    "Promise<void>",
+    "Promise<undefined>",
+    "Promise<never>",
+]);
+/** The prefix that marks a parameter as unused on purpose, as the compiler's own rule reads it. */
+const UNUSED_PREFIX = "_";
+/** The rendered position of one node, from its first token to its last line. */
+function spanOf(file, root, node) {
+    const start = renderPosition(file, root, node.getStart());
+    const endLine = file.getLineAndCharacterOfPosition(node.end).line + 1;
+    return { ...start, endLine };
+}
+/** The parenthesized expression's content, through every pair of parentheses. */
+function unwrapped(node) {
+    return isParenthesizedExpression(node) ? unwrapped(node.expression) : node;
+}
+/** The node the parentheses around one expression sit in. */
+function outerParent(node) {
+    return isParenthesizedExpression(node.parent) ? outerParent(node.parent) : node.parent;
+}
+/** The name a call is made through: the identifier, or the member a property access names. */
+function calleeName(call) {
+    const callee = unwrapped(call.expression);
+    if (isIdentifier(callee)) {
+        return callee;
+    }
+    return isPropertyAccessExpression(callee) && isIdentifier(callee.name) ? callee.name : undefined;
+}
+/**
+ * Whether a call's value is discarded: the call is a statement of its own, awaited as a
+ * statement, or the operand of `void`.
+ */
+function discarded(call) {
+    const parent = outerParent(call);
+    if (isExpressionStatement(parent) || isVoidExpression(parent)) {
+        return true;
+    }
+    return isAwaitExpression(parent) && isExpressionStatement(outerParent(parent));
+}
+/** Whether one statement leaves its statement list on every path: the rest of the list never runs. */
+function abrupt(statement) {
+    if (isReturnStatement(statement) ||
+        isThrowStatement(statement) ||
+        isBreakStatement(statement) ||
+        isContinueStatement(statement)) {
+        return true;
+    }
+    if (isBlock(statement)) {
+        return statement.statements.some(abrupt);
+    }
+    if (isIfStatement(statement)) {
+        return (statement.elseStatement !== undefined &&
+            abrupt(statement.thenStatement) &&
+            abrupt(statement.elseStatement));
+    }
+    return false;
+}
+/**
+ * Whether an unreachable statement is no subject: a declaration the language hoists or
+ * that emits nothing, an empty statement, and a `var` that initializes nothing.
+ */
+function unreachableExempt(statement) {
+    if (isFunctionDeclaration(statement) ||
+        isInterfaceDeclaration(statement) ||
+        isTypeAliasDeclaration(statement) ||
+        isModuleDeclaration(statement) ||
+        isEmptyStatement(statement)) {
+        return true;
+    }
+    if (isVariableStatement(statement)) {
+        const list = statement.declarationList;
+        return ((list.flags & (NodeFlags.Let | NodeFlags.Const | NodeFlags.Using)) === 0 &&
+            list.declarations.every((one) => one.initializer === undefined));
+    }
+    return false;
+}
+/** The value a case expression is a literal of, as a key two equal literals share, or none. */
+function caseKey(expression) {
+    const node = unwrapped(expression);
+    if (isStringLiteral(node) || isNoSubstitutionTemplateLiteral(node)) {
+        return `s:${node.text}`;
+    }
+    if (isNumericLiteral(node)) {
+        return `n:${String(Number(node.text))}`;
+    }
+    if (isBigIntLiteral(node)) {
+        return `b:${BigInt(node.text.slice(0, -1)).toString()}`;
+    }
+    if (isPrefixUnaryExpression(node) &&
+        node.operator === SyntaxKind.MinusToken &&
+        isNumericLiteral(node.operand)) {
+        return `n:${String(-Number(node.operand.text))}`;
+    }
+    if (node.kind === SyntaxKind.TrueKeyword ||
+        node.kind === SyntaxKind.FalseKeyword ||
+        node.kind === SyntaxKind.NullKeyword) {
+        return `k:${String(node.kind)}`;
+    }
+    return undefined;
+}
+/** Every identifier below one node whose text one of the names spells, a member's name aside. */
+function identifiersNaming(node, names) {
+    const found = [];
+    const visit = (at) => {
+        if (isIdentifier(at)) {
+            const parent = at.parent;
+            if (names.has(at.text) && !(isPropertyAccessExpression(parent) && parent.name === at)) {
+                found.push(at);
+            }
+            return;
+        }
+        at.forEachChild(visit);
+    };
+    visit(node);
+    return found;
+}
+/** Whether one node is below another, or is it. */
+function within(node, container) {
+    return node.pos >= container.pos && node.end <= container.end;
+}
+/** Whether a node is written inside a function nested in `outer`, which may run at any time. */
+function inNestedFunction(node, outer) {
+    for (let at = node.parent; at !== outer; at = at.parent) {
+        if (isArrowFunction(at) ||
+            at.kind === SyntaxKind.FunctionExpression ||
+            isFunctionDeclaration(at) ||
+            isMethodDeclaration(at) ||
+            isClassDeclaration(at) ||
+            isClassExpression(at) ||
+            at.kind === SyntaxKind.GetAccessor ||
+            at.kind === SyntaxKind.SetAccessor ||
+            at.kind === SyntaxKind.Constructor) {
+            return true;
+        }
+    }
+    return false;
+}
+/** Whether a body is a stub: it holds no statement, or nothing but `throw` statements. */
+function isStub(signature) {
+    const body = signature.body;
+    return body !== undefined && isBlock(body) && body.statements.every(isThrowStatement);
+}
+/** Whether a function's body or signature returns a value: an expression body, or `return` with one. */
+function returnsAValue(signature) {
+    const body = signature.body;
+    if (body === undefined) {
+        return false;
+    }
+    if (!isBlock(body)) {
+        return true;
+    }
+    let found = false;
+    const visit = (node) => {
+        if (found || inNestedFunction(node, signature)) {
+            return;
+        }
+        if (isReturnStatement(node) && node.expression !== undefined) {
+            found = true;
+            return;
+        }
+        node.forEachChild(visit);
+    };
+    body.forEachChild(visit);
+    return found;
+}
+/** Whether one node is written with a modifier of one kind. */
+function hasModifier(node, kind) {
+    return (node.modifiers ?? []).some((modifier) => modifier.kind === kind);
+}
+/** Every class name an `extends` clause of the project names, by its last identifier. */
+function extendedNames(files) {
+    const names = new Set();
+    const visit = (node) => {
+        if (isHeritageClause(node) && node.token === SyntaxKind.ExtendsKeyword) {
+            for (const type of node.types) {
+                const expression = unwrapped(type.expression);
+                const named = isPropertyAccessExpression(expression) ? expression.name : expression;
+                if (isIdentifier(named)) {
+                    names.add(named.text);
+                }
+            }
+        }
+        node.forEachChild(visit);
+    };
+    for (const file of files) {
+        file.forEachChild(visit);
+    }
+    return names;
+}
+/**
+ * Whether a class hierarchy fixes one method's signature: its class extends or implements
+ * another type, is abstract or is extended itself, or the method is marked `override`.
+ */
+function hierarchyFixes(declared, extended) {
+    if (!isMethodDeclaration(declared)) {
+        return false;
+    }
+    const owner = declared.parent;
+    if (!isClassDeclaration(owner) && !isClassExpression(owner)) {
+        return false;
+    }
+    if (hasModifier(declared, SyntaxKind.OverrideKeyword) ||
+        hasModifier(owner, SyntaxKind.AbstractKeyword)) {
+        return true;
+    }
+    if ((owner.heritageClauses ?? []).length > 0) {
+        return true;
+    }
+    return owner.name !== undefined && extended.has(owner.name.text);
+}
+/** The symbol identifier each of a batch of identifiers resolves to, where the batch answers. */
+function resolvedIds(project, nodes) {
+    const ids = new Map();
+    for (let from = 0; from < nodes.length; from += DEFAULT_BATCH_CAP) {
+        const run = nodes.slice(from, from + DEFAULT_BATCH_CAP);
+        project.symbolsAt(run.map((node) => project.handle(node))).forEach((symbol, index) => {
+            const node = run[index];
+            if (symbol !== undefined && node !== undefined) {
+                ids.set(node, symbol.id);
+            }
+        });
+    }
+    return ids;
+}
+/**
+ * Whether one identifier reads the binding a name node declares: it resolves to the
+ * same symbol, or the checker resolves it to nothing, which is read as a use rather than
+ * risk a finding; a shorthand property reads the binding of its own name.
+ */
+function readsBinding(use, declared, ids) {
+    if (isShorthandPropertyAssignment(use.parent)) {
+        return true;
+    }
+    const at = ids.get(use);
+    return at === undefined || at === ids.get(declared);
+}
+/**
+ * The parts of one project's own declarations. `references` are the project's own
+ * references, which say which declarations a discarded call reaches, so the checker is
+ * asked for a result's type only where a call discards it.
+ */
+export function projectParts(project, held, references, targetRoot) {
+    const files = project.ownSourceFiles();
+    const extended = extendedNames(files);
+    const kinds = new Map(held.symbols.map((symbol) => [symbol.id, symbol.kind]));
+    const parts = [];
+    const signatures = [];
+    const calls = new Map();
+    const specifiers = new Set();
+    const sites = [];
+    for (const file of files) {
+        const declarationAt = (node) => {
+            const id = held.declarations.get(nodeKey(file, node));
+            return id === undefined || kinds.get(id) === "file" ? undefined : id;
+        };
+        const holderOf = (node) => {
+            for (let at = node.parent; at.kind !== SyntaxKind.SourceFile; at = at.parent) {
+                const id = declarationAt(at);
+                if (id !== undefined) {
+                    return id;
+                }
+            }
+            return undefined;
+        };
+        const walk = { declared: [], blocks: [], unreachable: [], cases: [] };
+        const position = (node) => positionKey(renderPosition(file, targetRoot, node.getStart()));
+        // Code below an unreachable statement is still walked for its calls and specifiers,
+        // and reports no part of its own: the unreachable statement is the one finding.
+        let silenced = 0;
+        const statementsOf = (statements) => {
+            let reachable = true;
+            let reported = false;
+            for (const statement of statements) {
+                if (reachable) {
+                    visit(statement);
+                    reachable = !abrupt(statement);
+                    continue;
+                }
+                const holder = holderOf(statement);
+                if (silenced === 0 && !reported && !unreachableExempt(statement) && holder !== undefined) {
+                    walk.unreachable.push({ statement, holder });
+                    reported = true;
+                }
+                silenced += 1;
+                visit(statement);
+                silenced -= 1;
+            }
+        };
+        const visit = (node) => {
+            const id = declarationAt(node);
+            const signature = id === undefined ? undefined : signatureOf(node);
+            if (id !== undefined && signature !== undefined) {
+                walk.declared.push({ id, node, signature });
+            }
+            if (isCallExpression(node)) {
+                const name = calleeName(node);
+                if (name !== undefined) {
+                    calls.set(position(name), discarded(node));
+                }
+            }
+            if (isImportSpecifier(node) || isExportSpecifier(node)) {
+                for (const name of [node.propertyName, node.name]) {
+                    if (name !== undefined) {
+                        specifiers.add(position(name));
+                    }
+                }
+            }
+            if ((isImportClause(node) || isNamespaceImport(node)) && node.name !== undefined) {
+                specifiers.add(position(node.name));
+            }
+            if (isExportAssignment(node) && isIdentifier(unwrapped(node.expression))) {
+                specifiers.add(position(unwrapped(node.expression)));
+            }
+            if (isSwitchStatement(node)) {
+                const holder = holderOf(node);
+                const seen = new Set();
+                for (const clause of node.caseBlock.clauses) {
+                    if (!isCaseClause(clause)) {
+                        continue;
+                    }
+                    const key = caseKey(clause.expression);
+                    if (key !== undefined && seen.has(key) && holder !== undefined && silenced === 0) {
+                        walk.cases.push({ clause, text: clause.expression.getText(), holder });
+                    }
+                    if (key !== undefined) {
+                        seen.add(key);
+                    }
+                }
+            }
+            if (isBlock(node) && silenced === 0 && holderOf(node) !== undefined) {
+                walk.blocks.push(node);
+            }
+            if (isBlock(node) || isCaseClause(node) || isDefaultClause(node)) {
+                statementsOf(node.statements);
+                return;
+            }
+            node.forEachChild(visit);
+        };
+        file.forEachChild(visit);
+        // One batch per file resolves every name a parameter or a local is read through.
+        const asked = [];
+        const readers = new Map();
+        for (const one of walk.declared) {
+            const names = one.signature.parameters
+                .map((parameter) => parameter.name)
+                .filter(isIdentifier);
+            const spelled = new Set(names.map((name) => name.text));
+            const uses = identifiersNaming(one.signature, spelled).filter((use) => !names.includes(use));
+            readers.set(one, { names, uses });
+            asked.push(...names, ...uses);
+        }
+        const stores = walk.blocks.map((block) => localsOf(block));
+        for (const store of stores) {
+            asked.push(...store.flatMap((local) => [local.name, ...local.uses]));
+        }
+        const ids = resolvedIds(project, [...new Set(asked)]);
+        for (const one of walk.declared) {
+            sites.push({ file, declared: one });
+            signatures.push({
+                declaration: one.id,
+                stub: isStub(one.signature),
+                fixed: hierarchyFixes(one.node, extended),
+            });
+            const { uses } = readers.get(one) ?? { uses: [] };
+            parts.push(...parameterParts(file, targetRoot, one, uses, ids));
+        }
+        walk.blocks.forEach((block, at) => {
+            const holder = holderOf(block);
+            if (holder !== undefined) {
+                parts.push(...deadStores(file, targetRoot, block, holder, stores[at] ?? [], ids));
+            }
+        });
+        for (const { statement, holder } of walk.unreachable) {
+            parts.push({
+                code: UNREACHABLE_STATEMENT,
+                declaration: holder,
+                kind: "statement",
+                name: "statement",
+                position: spanOf(file, targetRoot, statement),
+                message: "statement is unreachable",
+                used: false,
+            });
+        }
+        for (const { clause, text, holder } of walk.cases) {
+            parts.push({
+                code: UNREACHABLE_CASE,
+                declaration: holder,
+                kind: "case",
+                name: text,
+                position: spanOf(file, targetRoot, clause),
+                message: `case ${text} is covered by an earlier case of the same switch`,
+                used: false,
+            });
+        }
+    }
+    parts.push(...resultParts(project, targetRoot, sites, references, calls));
+    return { parts, signatures, calls, specifiers };
+}
+/** Each named parameter of one function and whether the function reads it. */
+function parameterParts(file, root, one, uses, ids) {
+    const signature = one.signature;
+    // A function that reads `arguments` reads every parameter by position.
+    const readsArguments = !isArrowFunction(signature) && identifiersNaming(signature, new Set(["arguments"])).length > 0;
+    const found = [];
+    for (const parameter of signature.parameters) {
+        const name = parameter.name;
+        if (!isIdentifier(name) ||
+            name.text === "this" ||
+            name.text.startsWith(UNUSED_PREFIX) ||
+            (parameter.modifiers ?? []).some(isDecorator)) {
+            continue;
+        }
+        found.push({
+            code: UNUSED_PARAMETER,
+            declaration: one.id,
+            kind: "parameter",
+            name: name.text,
+            position: spanOf(file, root, name),
+            message: `parameter ${name.text} is never read in the body`,
+            used: readsArguments ||
+                uses.some((use) => use.text === name.text && readsBinding(use, name, ids)),
+        });
+    }
+    return found;
+}
+/** The locals one block declares with `let` or `const`, each with the names that spell it. */
+function localsOf(block) {
+    const declared = [];
+    block.statements.forEach((statement, at) => {
+        if (!isVariableStatement(statement)) {
+            return;
+        }
+        const list = statement.declarationList;
+        if ((list.flags & (NodeFlags.Let | NodeFlags.Const)) === 0 ||
+            (list.flags & NodeFlags.Using) !== 0) {
+            return;
+        }
+        for (const declaration of list.declarations) {
+            if (isIdentifier(declaration.name)) {
+                declared.push({
+                    name: declaration.name,
+                    statement: at,
+                    initialized: declaration.initializer !== undefined,
+                });
+            }
+        }
+    });
+    if (declared.length === 0) {
+        return [];
+    }
+    const spelled = identifiersNaming(block, new Set(declared.map((one) => one.name.text)));
+    return declared.map((one) => ({
+        ...one,
+        uses: spelled.filter((use) => use !== one.name && use.text === one.name.text),
+    }));
+}
+/**
+ * The writes to the locals of one block that no read reaches. A write is a declaration's
+ * initializer or a plain assignment written as a statement of the block itself; it is
+ * dead when the statements after it in the block read the local nowhere before the next
+ * such write to it, or before the block ends, which ends the local's scope. A statement
+ * that writes the local inside a nested construct ends the search with the write kept,
+ * and a local a nested function names is no subject, because the function may read it
+ * at any time.
+ */
+function deadStores(file, root, block, holder, locals, ids) {
+    const found = [];
+    for (const local of locals) {
+        const uses = local.uses.filter((use) => readsBinding(use, local.name, ids));
+        if (uses.some((use) => inNestedFunction(use, block))) {
+            continue;
+        }
+        const statements = block.statements;
+        const usesIn = (statement) => uses.filter((use) => within(use, statement));
+        /** The plain assignment to the local a statement of the block is, where it is one. */
+        const writeOf = (statement) => {
+            if (!isExpressionStatement(statement)) {
+                return undefined;
+            }
+            const expression = unwrapped(statement.expression);
+            if (!isBinaryExpression(expression) ||
+                expression.operatorToken.kind !== SyntaxKind.EqualsToken) {
+                return undefined;
+            }
+            const target = unwrapped(expression.left);
+            return isIdentifier(target) && uses.includes(target)
+                ? { target, value: expression.right }
+                : undefined;
+        };
+        const writes = [];
+        if (local.initialized) {
+            writes.push({ at: local.statement, target: local.name });
+        }
+        statements.forEach((statement, at) => {
+            const write = writeOf(statement);
+            if (write !== undefined && at > local.statement) {
+                writes.push({ at, target: write.target });
+            }
+        });
+        for (const write of writes) {
+            // The rest of the write's own statement runs after it: a later declarator may read the local.
+            const own = statements[write.at];
+            const sameStatement = own !== undefined && write.target === local.name
+                ? usesIn(own).filter((use) => use !== local.name)
+                : [];
+            if (sameStatement.length > 0) {
+                continue;
+            }
+            let dead = true;
+            for (let at = write.at + 1; at < statements.length; at += 1) {
+                const statement = statements[at];
+                if (statement === undefined) {
+                    break;
+                }
+                const next = writeOf(statement);
+                if (next !== undefined) {
+                    dead = usesIn(next.value).length === 0;
+                    break;
+                }
+                const named = usesIn(statement);
+                if (named.length > 0) {
+                    dead = false;
+                    break;
+                }
+            }
+            if (!dead) {
+                continue;
+            }
+            const position = spanOf(file, root, write.target);
+            found.push({
+                code: DEAD_STORE,
+                declaration: holder,
+                kind: "store",
+                name: local.name.text,
+                position,
+                message: `value written to ${local.name.text} is never read`,
+                used: false,
+            });
+        }
+    }
+    return found;
+}
+/**
+ * The result of each function a discarded call reaches, where its type carries a value:
+ * whether it is used is the call sites' to say, which the run decides over every project.
+ */
+function resultParts(project, root, sites, references, calls) {
+    const discardedAt = new Set(references.filter((one) => calls.get(positionKey(one.position)) === true).map((one) => one.to));
+    const found = [];
+    for (const { file, declared } of sites) {
+        const { signature, node, id } = declared;
+        const generator = signature.asteriskToken !== undefined;
+        if (!discardedAt.has(id) || generator || !returnsAValue(signature)) {
+            continue;
+        }
+        const typed = project.checker.getSignatureFromDeclaration(signature);
+        const result = typed === undefined ? undefined : project.checker.getReturnTypeOfSignature(typed);
+        if (result === undefined || NO_VALUE.has(project.checker.typeToString(result))) {
+            continue;
+        }
+        const at = signature.type ?? node.name ?? node;
+        found.push({
+            code: UNUSED_RESULT,
+            declaration: id,
+            kind: "result",
+            name: "result",
+            position: spanOf(file, root, at),
+            message: "result is discarded at every call site",
+            used: false,
+        });
+    }
+    return found;
+}
+/**
+ * The parts of a run's projects merged: a part two projects hold is one part, in use
+ * where either found it in use. A signature is free when no exemption record names its
+ * declaration, its body is no stub, no class hierarchy fixes it, and every reference to
+ * the declaration is a call or a specifier: any other reference uses the function as a
+ * value, whose type then fixes the signature, and a reference a consumer makes is one
+ * whose form this run does not read.
+ */
+export function intraFunctionFacts(projects, references, exempted) {
+    const parts = new Map();
+    for (const part of projects.flatMap((one) => one.parts)) {
+        const key = `${part.code}\u0000${positionKey(part.position)}`;
+        const known = parts.get(key);
+        parts.set(key, known === undefined ? part : { ...known, used: known.used || part.used });
+    }
+    const calls = new Map();
+    const specifiers = new Set();
+    for (const one of projects) {
+        for (const [at, value] of one.calls) {
+            calls.set(at, value);
+        }
+        for (const at of one.specifiers) {
+            specifiers.add(at);
+        }
+    }
+    const valued = new Set();
+    const called = new Map();
+    for (const reference of references) {
+        if (reference.use === "decorator" || reference.use === "evaluation") {
+            continue;
+        }
+        const at = positionKey(reference.position);
+        const call = reference.consumer === undefined ? calls.get(at) : undefined;
+        if (call !== undefined) {
+            called.set(reference.to, (called.get(reference.to) ?? true) && call);
+        }
+        else if (reference.consumer !== undefined || !specifiers.has(at)) {
+            valued.add(reference.to);
+        }
+    }
+    const signatures = projects.flatMap((one) => one.signatures);
+    const fixed = new Set(signatures.filter((one) => one.stub || one.fixed).map((one) => one.declaration));
+    const free = new Set(signatures
+        .map((one) => one.declaration)
+        .filter((id) => !fixed.has(id) && !exempted.has(id) && !valued.has(id)));
+    const discardedEverywhere = new Set([...called].filter(([id, all]) => all && !valued.has(id)).map(([id]) => id));
+    return { parts: [...parts.values()], free, discardedEverywhere };
+}