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

package/dist/src/exemptions/sites.js

@@ -0,0 +1,182 @@
+/**
+ * The one walk of a project's own files every detector shares: its calls and the class
+ * `this` stands for at each, its classes, the values it hands to positions typed by
+ * their context, its functions' parameters, its decorated declarations and its
+ * assignments to properties. The walk reads syntax only; what a call invokes through a
+ * method of `Function.prototype` asks the checker, once per project, at the first
+ * detector that needs it.
+ */
+import { isArrowFunction, isBinaryExpression, isClassDeclaration, isClassExpression, isClassStaticBlockDeclaration, isElementAccessExpression, isFunctionDeclaration, isFunctionExpression, isGetAccessorDeclaration, isIdentifier, isMethodDeclaration, isNoSubstitutionTemplateLiteral, isObjectLiteralExpression, isPropertyAccessExpression, isPropertyDeclaration, isSetAccessorDeclaration, isStringLiteral, isVariableDeclaration, ModifierFlags, SyntaxKind, } from "@typescript/native/ast";
+import { handedOn, valuesOf } from "../index/values.js";
+import { isParameterProperty, nodeKey } from "../inventory.js";
+import { parenthesesRemoved } from "../unwrap.js";
+import { decoratorsOf, invocations } from "./calls.js";
+/** The property one assignment's left side names on its receiver, where a written key names it. */
+function storeOf(node) {
+    if (!isBinaryExpression(node) || node.operatorToken.kind !== SyntaxKind.EqualsToken) {
+        return undefined;
+    }
+    const left = parenthesesRemoved(node.left);
+    if (isPropertyAccessExpression(left) && isIdentifier(left.name)) {
+        return { store: node, receiver: left.expression, key: left.name.text, value: node.right };
+    }
+    if (isElementAccessExpression(left) &&
+        (isStringLiteral(left.argumentExpression) ||
+            isNoSubstitutionTemplateLiteral(left.argumentExpression))) {
+        return {
+            store: node,
+            receiver: left.expression,
+            key: left.argumentExpression.text,
+            value: node.right,
+        };
+    }
+    return undefined;
+}
+/** Whether one node declares a static member, whose `this` is the class itself. */
+function isStatic(node) {
+    const flags = node.modifierFlags ?? 0;
+    return (flags & ModifierFlags.Static) !== 0;
+}
+/**
+ * Whether one node opens a body whose `this` is no instance of the enclosing class: a
+ * function that is not an arrow, a static block, a static member, and a method or an
+ * accessor of an object literal, whose `this` is the literal.
+ */
+function resetsThis(node) {
+    return (isFunctionDeclaration(node) ||
+        isFunctionExpression(node) ||
+        isClassStaticBlockDeclaration(node) ||
+        isStatic(node) ||
+        ((isMethodDeclaration(node) ||
+            isGetAccessorDeclaration(node) ||
+            isSetAccessorDeclaration(node)) &&
+            isObjectLiteralExpression(node.parent)));
+}
+/** The parameters and declaring node of one function-like declaration of the project. */
+function functionOf(node) {
+    if (isFunctionDeclaration(node) ||
+        (isMethodDeclaration(node) && !isObjectLiteralExpression(node.parent))) {
+        return { declared: node, parameters: node.parameters };
+    }
+    if (isVariableDeclaration(node) &&
+        node.initializer !== undefined &&
+        (isArrowFunction(node.initializer) || isFunctionExpression(node.initializer))) {
+        return { declared: node, parameters: node.initializer.parameters };
+    }
+    return undefined;
+}
+function walk(project, held) {
+    const calls = [];
+    const classes = [];
+    const flows = [];
+    const parameters = [];
+    const decorated = [];
+    const stores = [];
+    const parameterProperties = new Set();
+    const initialized = new Set();
+    for (const file of project.ownSourceFiles()) {
+        const visit = (node, self) => {
+            const id = held.declarations.get(nodeKey(file, node));
+            let inner = self;
+            if (isClassDeclaration(node) || isClassExpression(node)) {
+                inner = id;
+                if (id !== undefined) {
+                    classes.push({ id, node });
+                }
+            }
+            else if (resetsThis(node)) {
+                inner = undefined;
+            }
+            if (id !== undefined) {
+                if (isParameterProperty(node)) {
+                    parameterProperties.add(id);
+                }
+                if (decoratorsOf(node).length > 0) {
+                    decorated.push({ id, node });
+                }
+                if (isPropertyDeclaration(node) && node.initializer !== undefined) {
+                    initialized.add(id);
+                }
+            }
+            if (node.kind === SyntaxKind.CallExpression) {
+                calls.push({ call: node, self: inner });
+            }
+            const store = storeOf(node);
+            if (store !== undefined) {
+                stores.push(store);
+            }
+            for (const written of handedOn(node)) {
+                for (const value of valuesOf(written)) {
+                    flows.push({ value, self: value.kind === SyntaxKind.ThisKeyword ? inner : undefined });
+                }
+            }
+            const fn = functionOf(node);
+            const fnId = fn === undefined ? undefined : held.declarations.get(nodeKey(file, fn.declared));
+            if (fn !== undefined && fnId !== undefined) {
+                fn.parameters
+                    .filter((parameter) => !(isIdentifier(parameter.name) && parameter.name.text === "this"))
+                    .forEach((parameter, index) => {
+                    if (isIdentifier(parameter.name)) {
+                        parameters.push({
+                            fn: fnId,
+                            index,
+                            rest: parameter.dotDotDotToken !== undefined,
+                            name: parameter.name,
+                        });
+                    }
+                });
+            }
+            node.forEachChild((child) => {
+                visit(child, inner);
+            });
+        };
+        file.forEachChild((child) => {
+            visit(child, undefined);
+        });
+    }
+    return {
+        calls,
+        classes,
+        flows,
+        parameters,
+        decorated,
+        stores,
+        parameterProperties,
+        initialized,
+    };
+}
+/** The sites of one project's own files, each walk and each checker question made once. */
+export function projectSites(project, held) {
+    let walked;
+    let invoked;
+    const sites = () => (walked ??= walk(project, held));
+    return {
+        get calls() {
+            return sites().calls;
+        },
+        get classes() {
+            return sites().classes;
+        },
+        get flows() {
+            return sites().flows;
+        },
+        get parameters() {
+            return sites().parameters;
+        },
+        get decorated() {
+            return sites().decorated;
+        },
+        get stores() {
+            return sites().stores;
+        },
+        get parameterProperties() {
+            return sites().parameterProperties;
+        },
+        get initialized() {
+            return sites().initialized;
+        },
+        get invocations() {
+            return (invoked ??= invocations(project, sites().calls.map((one) => one.call)));
+        },
+    };
+}

package/dist/src/{template-field.js → exemptions/template-field.js}

@@ -11,13 +11,13 @@
  * instance members of classes and the members of interfaces and object types, on any
  * type, because nothing ties the name to a type.
  */
-import { readComponent } from "./component-files.js";
-import { memberNames } from "./member-names.js";
-import { extensionOf, isAbsolutePath, joinPath, normalizePath, relativePath } from "./paths.js";
-import { isComponentFile } from "./position.js";
-import { bytewise } from "./text/compare.js";
-import { filesBelow } from "./fs/tree.js";
-import { UsageError } from "./usage.js";
+import { readComponent } from "../component-files.js";
+import { memberNames } from "../member-names.js";
+import { extensionOf, isAbsolutePath, joinPath, normalizePath, relativePath } from "../paths.js";
+import { isComponentFile } from "../position.js";
+import { bytewise } from "../text/compare.js";
+import { filesBelow } from "../fs/tree.js";
+import { UsageError } from "../usage.js";
 /** The kinds of declaration an action can name. */
 const READ_BY_A_TEMPLATE = new Set([
     "method",

package/dist/src/{value-reach.js → exemptions/value-reach.js}

@@ -2,14 +2,15 @@
  * 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 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.
+ * signatures of the types the target writes, a class's polymorphic `this` type, and the values
+ * `stored` gives for a type where it erases them. The walk stops at `any`, `unknown`, any
+ * other type parameter, a function and an interface or class of another program, so an
+ * instance held only there is missed.
  */
 import { isAsExpression, isParenthesizedExpression, isSatisfiesExpression, isTypeAssertion, } from "@typescript/native/ast";
-import { ObjectFlags, SymbolFlags, } from "@typescript/native/sync";
-import { classNames, typesAt } from "./class-members.js";
-import { must } from "./query.js";
+import { ObjectFlags, SymbolFlags, TypeFlags, } from "@typescript/native/sync";
+import { classNames, typesAt } from "../class-members.js";
+import { must } from "../query.js";
 /**
  * The object types whose members the walk reads whatever declares them. A reverse-mapped
  * type has no symbol: it is the shape the checker infers from an argument the target
@@ -19,7 +20,9 @@ const WRITTEN = ObjectFlags.ObjectLiteral | ObjectFlags.Mapped | ObjectFlags.Rev
 /** The symbols of an anonymous object type the target writes as a type. */
 const LITERAL_SYMBOLS = SymbolFlags.TypeLiteral | SymbolFlags.ObjectLiteral;
 /** The two conversion methods a serializer or a formatter resolves on a value's own shape. */
-const CONVERSION_NAMES = new Set(["toJSON", "toString"]);
+export const CONVERSION_NAMES = new Set(["toJSON", "toString"]);
+/** The types that keep nothing of a value they are given, or that a decode gives a value. */
+export const ERASED = TypeFlags.Any | TypeFlags.Unknown;
 /**
  * The members that can answer a conversion: a serializer reads the name with `[[Get]]`
  * and calls what it answers, so a getter answers it as a method does:
@@ -140,6 +143,10 @@ export function valueReach(project, held, stored = () => []) {
         if (type.isUnionType() || type.isIntersectionType()) {
             found = must(queries.constituents(type));
         }
+        else if (type.isTypeParameter() && type.isThisType === true) {
+            // A value of a class's polymorphic `this` type is an instance of the class.
+            found = [must(queries.constraintOf(type))].filter((one) => one !== undefined);
+        }
         else if (type.isObjectType()) {
             const target = targetOf(type);
             const isList = type.isTypeReference() &&

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

@@ -1,8 +1,21 @@
 import { CODE } from "../contract/contract.generated.js";
 import { KINDS } from "../kinds.js";
 import { parameterRef } from "../ref.js";
-import {} from "../intra-function-parts.js";
 import { reachedWithTheTests } from "../liveness/sweep.js";
+/** The code each part kind is reported under, and what its finding says before the overlap clause. */
+const PART_KINDS = {
+    parameter: {
+        code: CODE.unusedParameter,
+        says: (name) => `parameter ${name} is never read in the body`,
+    },
+    result: { code: CODE.unusedResult, says: () => "result is discarded at every call site" },
+    store: { code: CODE.deadStore, says: (name) => `value written to ${name} is never read` },
+    statement: { code: CODE.unreachableStatement, says: () => "statement is unreachable" },
+    case: {
+        code: CODE.unreachableCase,
+        says: (name) => `case ${name} is covered by an earlier case of the same switch`,
+    },
+};
 /** A list of rules as a sentence names them. */
 function spelled(rules) {
     if (rules.length < 2) {
@@ -25,17 +38,24 @@ function overlapClause(overlap, part) {
         : `also reported by ${spelled(rules)}`;
 }
 /**
- * Whether one unread parameter is reported, and how. Of a free signature it is deleted. A
- * caller may pass a function used as a value more arguments than it declares, so there one
- * a read parameter follows is renamed to an underscore name, which the compilers read as
- * declared unread, and one no read parameter follows is deleted: kept where the call's
- * inference may read its annotation, at `probable` where nothing reads the annotation or
- * where it is a name a contextually typed object pattern binds.
+ * Whether one unread parameter is reported, and how (DS1401's precondition). Of a free
+ * signature it is deleted. Of a function used as a value, one a read parameter follows is
+ * renamed to an underscore name, and any other is deleted, kept where the call's inference
+ * may read its annotation. A deletion is `probable` where an unread annotation or a
+ * contextual pattern may matter to the caller, or where `length` counts the parameter of
+ * a function used as a value or of a root, whose holder may count it.
  */
-function parameterVerdict(part, free, freeButValued) {
+function parameterVerdict(part, free, freeButValued, rooted) {
     const place = part.parameter;
+    const counted = place?.counted === true;
     if (place?.inValue !== true && free.has(part.declaration)) {
-        return place?.annotated === undefined ? { fix: "delete", confidence: "certain" } : undefined;
+        if (place?.annotated !== undefined) {
+            return undefined;
+        }
+        return {
+            fix: "delete",
+            confidence: counted && rooted.has(part.declaration) ? "probable" : "certain",
+        };
     }
     const valued = place?.inValue === true || freeButValued.has(part.declaration);
     if (!valued) {
@@ -47,7 +67,7 @@ function parameterVerdict(part, free, freeButValued) {
     if (place?.annotated === "steers") {
         return undefined;
     }
-    const unseen = place?.annotated === "free" || place?.contextualPattern === true;
+    const unseen = place?.annotated === "free" || place?.contextualPattern === true || counted;
     return { fix: "delete", confidence: unseen ? "probable" : "certain" };
 }
 /**
@@ -57,15 +77,12 @@ function parameterVerdict(part, free, freeButValued) {
  * exports to callers the run cannot see has no result to report. Every other part is
  * reported wherever no project found it in use.
  */
-function reported(input, part, callersUnknown) {
-    if (part.used) {
-        return false;
-    }
+function reported(input, part, rooted, callersUnknown) {
     const { free, freeButValued, discardedEverywhere } = input.intraFunction;
-    switch (part.code) {
-        case CODE.unusedParameter:
-            return parameterVerdict(part, free, freeButValued) !== undefined;
-        case CODE.unusedResult:
+    switch (part.kind) {
+        case "parameter":
+            return parameterVerdict(part, free, freeButValued, rooted) !== undefined;
+        case "result":
             return (free.has(part.declaration) &&
                 discardedEverywhere.has(part.declaration) &&
                 !callersUnknown.has(part.declaration));
@@ -93,43 +110,39 @@ export const intraFunction = (input) => {
         const testCode = union.test[at] === true || union.support[at] === true;
         return !testCode || (reached[at] === true && !testsOfDeadCode.has(id));
     };
-    const unknown = new Set(union.rooted.flatMap((root) => {
+    const rooted = new Set(union.rooted.flatMap((root) => {
         const symbol = union.symbols[root.at];
         return symbol === undefined ? [] : [symbol.id];
     }));
+    const unknown = new Set(rooted);
     const { declared, loaded } = input.boundary.consumers;
     const closed = input.config.consumers.complete && declared.every((id) => loaded.includes(id));
-    const published = (id) => {
-        const symbol = byId.get(id);
-        return (symbol !== undefined &&
-            symbol.kind !== "file" &&
-            (symbol.exported || published(symbol.parent)));
-    };
     if (!closed) {
-        for (const part of input.intraFunction.parts) {
-            if (published(part.declaration)) {
-                unknown.add(part.declaration);
-            }
+        for (const id of input.intraFunction.published) {
+            unknown.add(id);
         }
     }
     const found = [];
     for (const part of input.intraFunction.parts) {
         const declaration = byId.get(part.declaration);
-        const overlap = KINDS.get(part.code)?.overlap?.ts ?? [];
-        if (declaration === undefined || !judged(declaration.id) || !reported(input, part, unknown)) {
+        const { code, says } = PART_KINDS[part.kind];
+        const overlap = KINDS.get(code)?.overlap?.ts ?? [];
+        if (declaration === undefined ||
+            !judged(declaration.id) ||
+            !reported(input, part, rooted, unknown)) {
             continue;
         }
-        const verdict = part.code === CODE.unusedParameter
-            ? parameterVerdict(part, input.intraFunction.free, input.intraFunction.freeButValued)
+        const verdict = part.kind === "parameter"
+            ? parameterVerdict(part, input.intraFunction.free, input.intraFunction.freeButValued, rooted)
             : undefined;
         const message = verdict?.fix === "rename"
-            ? `${part.message}, and a read parameter follows it, so rename it to _${part.name}`
-            : part.message;
+            ? `${says(part.name)}, and a read parameter follows it, so rename it to _${part.name}`
+            : says(part.name);
         found.push({
-            code: part.code,
+            code,
             position: part.position,
             symbol: {
-                ...(part.code === CODE.unusedParameter
+                ...(part.kind === "parameter"
                     ? { ref: parameterRef(declaration.ref, part.name), holder: declaration.ref }
                     : { ref: declaration.ref }),
                 kind: part.kind,

package/dist/src/index/sites.js

@@ -15,7 +15,7 @@ import { writtenName } from "../platform-calls.js";
 import { isLoadCall } from "../roots/unseen-loads.js";
 import { keyNameOf } from "../symbol-keys.js";
 import { parenthesesRemoved } from "../unwrap.js";
-import { handedOn, valuesOf } from "../value-flow.js";
+import { handedOn, valuesOf } from "./values.js";
 /**
  * The operators whose left side one assignment stores into. A compound assignment is
  * among them: where its value is discarded it reads its target only to write the result

package/dist/src/index/values.js

@@ -0,0 +1,124 @@
+/**
+ * What a written expression evaluates to, the one definition every pass shares: the
+ * values it can be, the values a call's argument carries inside the literals it writes,
+ * and the positions a program hands a value to that the checker types from their context.
+ */
+import { isArrayLiteralExpression, isArrowFunction, isAsExpression, isBinaryExpression, isCallExpression, isConditionalExpression, isIdentifier, isNewExpression, isNonNullExpression, isObjectLiteralExpression, isOmittedExpression, isParameterDeclaration, isParenthesizedExpression, isPropertyAccessExpression, isPropertyAssignment, isPropertyDeclaration, isReturnStatement, isSatisfiesExpression, isShorthandPropertyAssignment, isSpreadAssignment, isSpreadElement, isVariableDeclaration, SyntaxKind, } from "@typescript/native/ast";
+/** The operators of an assignment whose right side is stored into the left side's type. */
+const STORES = new Set([
+    SyntaxKind.EqualsToken,
+    SyntaxKind.QuestionQuestionEqualsToken,
+    SyntaxKind.BarBarEqualsToken,
+    SyntaxKind.AmpersandAmpersandEqualsToken,
+]);
+/** Whether a declaration writes its type, so its initializer is read in that type's context. */
+function writesType(node) {
+    return node.type !== undefined;
+}
+/**
+ * The expressions one written value can evaluate to, each read alone because the checker
+ * reduces a union by subtype, so the type at the whole drops a class another branch's
+ * extends: the operand of a spread, of parentheses and of `!`, each branch of a
+ * conditional, each operand of `??` and `||`, and the right operand of `&&` and of a
+ * comma. The left operand of `&&` is its value only where it is falsy, which no object
+ * is. An assertion is a value of its own, whose type its reader decides.
+ */
+export function valuesOf(expression) {
+    if (isSpreadElement(expression) || isParenthesizedExpression(expression)) {
+        return valuesOf(expression.expression);
+    }
+    if (isNonNullExpression(expression)) {
+        return valuesOf(expression.expression);
+    }
+    if (isConditionalExpression(expression)) {
+        return [...valuesOf(expression.whenTrue), ...valuesOf(expression.whenFalse)];
+    }
+    if (isBinaryExpression(expression)) {
+        const operator = expression.operatorToken.kind;
+        if (operator === SyntaxKind.QuestionQuestionToken || operator === SyntaxKind.BarBarToken) {
+            return [...valuesOf(expression.left), ...valuesOf(expression.right)];
+        }
+        if (operator === SyntaxKind.AmpersandAmpersandToken || operator === SyntaxKind.CommaToken) {
+            return valuesOf(expression.right);
+        }
+    }
+    return [expression];
+}
+/** The name node a callee, a decorator expression or a value resolves through, where it has one. */
+export function nameOf(expression) {
+    if (isParenthesizedExpression(expression)) {
+        return nameOf(expression.expression);
+    }
+    if (isPropertyAccessExpression(expression)) {
+        return expression.name;
+    }
+    return isIdentifier(expression) ? expression : undefined;
+}
+/**
+ * The values one argument carries: each value it can be ({@link valuesOf}), or what an
+ * array or object literal it can be holds, at any depth, through spreads and shorthand
+ * properties. Each value is read inside every assertion around it.
+ */
+export function carriedValues(argument) {
+    return valuesOf(argument).flatMap((value) => {
+        let at = value;
+        while (isAsExpression(at) || isSatisfiesExpression(at)) {
+            at = at.expression;
+        }
+        if (at !== value) {
+            return carriedValues(at);
+        }
+        if (isArrayLiteralExpression(value)) {
+            return value.elements.flatMap(carriedValues);
+        }
+        if (isObjectLiteralExpression(value)) {
+            return value.properties.flatMap((property) => {
+                if (isPropertyAssignment(property)) {
+                    return carriedValues(property.initializer);
+                }
+                if (isSpreadAssignment(property)) {
+                    return carriedValues(property.expression);
+                }
+                return isShorthandPropertyAssignment(property)
+                    ? [{ site: property.name, name: property, shorthand: true }]
+                    : [];
+            });
+        }
+        return isOmittedExpression(value)
+            ? []
+            : [{ site: value, name: nameOf(value), shorthand: false }];
+    });
+}
+/** The expressions one node hands to a position typed by its context. */
+export function handedOn(node) {
+    if ((isVariableDeclaration(node) || isPropertyDeclaration(node) || isParameterDeclaration(node)) &&
+        node.initializer !== undefined &&
+        writesType(node)) {
+        return [node.initializer];
+    }
+    if (isBinaryExpression(node) && STORES.has(node.operatorToken.kind)) {
+        return [node.right];
+    }
+    if (isCallExpression(node) || isNewExpression(node)) {
+        return (node.arguments ?? []).filter((argument) => !isSpreadElement(argument));
+    }
+    if (isReturnStatement(node)) {
+        return node.expression === undefined ? [] : [node.expression];
+    }
+    if (isArrowFunction(node)) {
+        return node.body.kind === SyntaxKind.Block ? [] : [node.body];
+    }
+    if (isArrayLiteralExpression(node)) {
+        return node.elements.filter((element) => !isSpreadElement(element) && element.kind !== SyntaxKind.OmittedExpression);
+    }
+    if (isPropertyAssignment(node)) {
+        return [node.initializer];
+    }
+    if (isShorthandPropertyAssignment(node)) {
+        return isIdentifier(node.name) ? [node.name] : [];
+    }
+    if (isAsExpression(node) || isSatisfiesExpression(node)) {
+        return [node.expression];
+    }
+    return [];
+}