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

package/dist/src/conformance-record.js

@@ -4,7 +4,7 @@ export const RECORD = {
     conformance: {
         corpusVersion: "6.1.0",
         result: "pass",
-        digest: "sha256:352b870acbc05213d4869bc18611137d0782cc0c9a8379e7a998a3d9cea2d966",
+        digest: "sha256:fcfdf88a7d45e1ac96545ef10c8427462260f4e81641d4d808b80086256bb6b7",
     },
     gaps: [],
 };

package/dist/src/contract/contract.generated.js

@@ -266,7 +266,7 @@ export const KIND_ROWS = [
         subject: "part",
         holdsLive: false,
         rule: "A parameter with no reference inside its function body, on a function whose signature is free to change.",
-        precondition: "The signature must be free, defined as follows: the function is not a method retained by interface satisfaction, is not a method whose name and signature are those of a method of an exported interface type declared by a package outside the target that the import closure holds, is not used as a value, is not a go:linkname or cgo target, is not a go-fuzz entry point, is not a function the Go test driver runs (a test, benchmark or fuzz test of a test file, or TestMain), and is not a stub whose body is empty or only panics. A function literal or function expression that initializes a variable the program only calls, never passing, storing, returning or assigning it, is called by name and is not used as a value. In Go a function literal that is the callee of the call it is written in, the call of a `go` or a `defer` statement included, is not used as a value, wherever the literal is written. A parameter its body never names is dead whatever the callers, so a published declaration of a library is reported too, with the fixability the vocabulary gives the kind: the signature change is a breaking change. In TypeScript a caller may pass a function used as a value more arguments than it declares parameters, so in such a function whose signature is free but for that use, a parameter its body never reads is reported for deletion when its body reads no parameter after it, and an unread parameter before the last read one is reported for a rename to its name with a leading underscore, which keeps every argument in place and which the compilers' unused-parameter rules read as declared unread, unless its name already starts with one. A parameter of a TypeScript function expression or arrow function that the compiler gives a contextual type, and that carries a type annotation, is not reported for deletion where the inference of the call holding the function may read the annotation, being where the callee is generic and its parameter type at the function's place names a type parameter at the parameter's place, or where the function is written inside an object literal such a call is passed, and it is reported for deletion at `probable` where it carries an annotation no such inference reads, because nothing in the program shows that an outside reader ignores it. A name an object binding pattern of a parameter of such a function binds, annotated or not, that the body never reads is reported for deletion at `probable`, because the pattern reads the property it names from the argument and the code that hands the argument may act on that read, which nothing in the program shows. Any other TypeScript parameter that is a binding pattern is judged by the names it binds: each name the body never reads is reported wherever the pattern stands, because removing it from the pattern moves no argument, except a name beside a rest element of the same object pattern, whose removal changes what that element holds, and the pattern counts as a read parameter when the body reads any name it binds. A rest parameter is judged as the last parameter. A TypeScript `this` parameter declares the type of `this` and receives no argument, so it is never reported. A TypeScript constructor is used as a value where its class is used as a value other than as the callee of a `new` expression or the class an `extends` clause names, and its signature is not free where its class carries a decorator or a parameter of the constructor carries one, because the code that decorator or a container runs may construct the class. A parameter property is read by the write to its member the constructor makes, so it is never reported under this kind, and its member is judged under DS1301. A TypeScript name a parameter binds, whole or through a binding pattern, that starts with an underscore is never reported, because a leading underscore is the spelling unused-parameter rules read as declared unread, and no other name exempts a parameter. A Go parameter named by the blank identifier declares no name a body could read and is never reported.",
+        precondition: "The signature must be free, defined as follows: the function is not a method retained by interface satisfaction, is not a method whose name and signature are those of a method of an exported interface type declared by a package outside the target that the import closure holds, is not used as a value, is not a go:linkname or cgo target, is not a go-fuzz entry point, is not a function the Go test driver runs (a test, benchmark or fuzz test of a test file, or TestMain), and is not a stub whose body is empty or only panics. A function literal or function expression that initializes a variable the program only calls, never passing, storing, returning or assigning it, is called by name and is not used as a value. In Go a function literal that is the callee of the call it is written in, the call of a `go` or a `defer` statement included, is not used as a value, wherever the literal is written. A parameter its body never names is dead whatever the callers, so a published declaration of a library is reported too, with the fixability the vocabulary gives the kind: the signature change is a breaking change. In TypeScript a caller may pass a function used as a value more arguments than it declares parameters, so in such a function whose signature is free but for that use, a parameter its body never reads is reported for deletion when its body reads no parameter after it, and an unread parameter before the last read one is reported for a rename to its name with a leading underscore, which keeps every argument in place and which the compilers' unused-parameter rules read as declared unread, unless its name already starts with one. A function's `length` counts each parameter before the first one with a default or a rest, and code holding the function may read it, so in TypeScript an unread parameter that `length` counts is reported at `probable` where the function is used as a value or is a root, which a library's published API is and which code outside the program calls, and a function whose `length` the program reads through its own name reports no parameter. A parameter of a TypeScript function expression or arrow function that the compiler gives a contextual type, and that carries a type annotation, is not reported for deletion where the inference of the call holding the function may read the annotation, being where the callee is generic and its parameter type at the function's place names a type parameter at the parameter's place, or where the function is written inside an object literal such a call is passed, and it is reported for deletion at `probable` where it carries an annotation no such inference reads, because nothing in the program shows that an outside reader ignores it. A name an object binding pattern of a parameter of such a function binds, annotated or not, that the body never reads is reported for deletion at `probable`, because the pattern reads the property it names from the argument and the code that hands the argument may act on that read, which nothing in the program shows. Any other TypeScript parameter that is a binding pattern is judged by the names it binds: each name the body never reads is reported wherever the pattern stands, because removing it from the pattern moves no argument, except a name beside a rest element of the same object pattern, whose removal changes what that element holds, and the pattern counts as a read parameter when the body reads any name it binds. A rest parameter is judged as the last parameter. A TypeScript `this` parameter declares the type of `this` and receives no argument, so it is never reported. A TypeScript constructor is used as a value where its class is used as a value other than as the callee of a `new` expression or the class an `extends` clause names, and its signature is not free where its class carries a decorator or a parameter of the constructor carries one, because the code that decorator or a container runs may construct the class. A parameter property is read by the write to its member the constructor makes, so it is never reported under this kind, and its member is judged under DS1301. A TypeScript name a parameter binds, whole or through a binding pattern, that starts with an underscore is never reported, because a leading underscore is the spelling unused-parameter rules read as declared unread, and no other name exempts a parameter. A Go parameter named by the blank identifier declares no name a body could read and is never reported.",
         details: { overlap: "required" },
         defaultEnabled: true,
         defaultSeverity: "warn",

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,