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

package/dist/src/erased-stores.js

@@ -0,0 +1,317 @@
+/**
+ * The values the program stores in a slot of a container: a property, an index signature,
+ * an array element, and a variable. A serializer walking the container emits the value the
+ * slot holds, so it walks each stored value at its own static type, a subtype stored where
+ * the slot's type names a supertype, `object`, `unknown` or `any` included. A container is
+ * identified by the checker's type identity, so two containers of one type share what
+ * either stores. A store into an erased property of a type the analyzed program does not
+ * declare hands the value to the code that declares the type.
+ */
+import { isArrayLiteralExpression, isBinaryExpression, isCallExpression, isElementAccessExpression, isIdentifier, isNoSubstitutionTemplateLiteral, isNumericLiteral, isObjectLiteralExpression, isParenthesizedExpression, isPropertyAccessExpression, isPropertyAssignment, isShorthandPropertyAssignment, isSpreadElement, isStringLiteral, isVariableDeclaration, SyntaxKind, } from "@typescript/native/unstable/ast";
+import { SymbolFlags, TypeFlags } from "@typescript/native/unstable/sync";
+import { must } from "./query.js";
+/** The types that keep nothing of the value they are given. */
+const ERASED = TypeFlags.Any | TypeFlags.Unknown;
+/** The array methods whose arguments become elements of the array they are called on. */
+const ELEMENT_STORES = new Set(["push", "unshift"]);
+/** The name an element access's literal index spells, or none. */
+function literalKey(node) {
+    return isStringLiteral(node) || isNoSubstitutionTemplateLiteral(node) || isNumericLiteral(node)
+        ? node.text
+        : undefined;
+}
+function unwrapped(node) {
+    return isParenthesizedExpression(node) ? unwrapped(node.expression) : node;
+}
+/**
+ * Whether a variable declaration's type can differ from what is stored in it: it carries an
+ * annotation, or it has neither an annotation nor an initializer, so its type evolves.
+ */
+function declaresSlot(node) {
+    const held = node;
+    return held.type !== undefined || held.initializer === undefined;
+}
+/** The element of an array literal at one place, where no spread before it moves the places. */
+function elementAt(source, at) {
+    if (!isArrayLiteralExpression(source)) {
+        return undefined;
+    }
+    const before = source.elements.slice(0, at + 1);
+    return before.some((one) => isSpreadElement(one)) ? undefined : source.elements[at];
+}
+/** The name a property spells, and none for a computed one. */
+function propertyName(name) {
+    return isIdentifier(name) || isStringLiteral(name) || isNumericLiteral(name)
+        ? name.text
+        : undefined;
+}
+/** The name one property of an object literal spells and the expression it holds, or none. */
+function propertyParts(property) {
+    if (isPropertyAssignment(property)) {
+        const name = propertyName(property.name);
+        return name === undefined ? undefined : { name, value: property.initializer };
+    }
+    if (isShorthandPropertyAssignment(property) && isIdentifier(property.name)) {
+        return { name: property.name.text, value: property.name };
+    }
+    return undefined;
+}
+/** The value an object literal gives one property, where it gives it by a plain or a shorthand property. */
+function propertyAt(source, name) {
+    if (!isObjectLiteralExpression(source)) {
+        return undefined;
+    }
+    for (const property of source.properties) {
+        const parts = propertyParts(property);
+        if (parts?.name === name) {
+            return parts.value;
+        }
+    }
+    return undefined;
+}
+/**
+ * Every target one destructuring pattern writes at any depth, each with the expression
+ * whose value it receives: the matching element or property of a literal on the right,
+ * else the right side with the path into it. A rest element copies, so it is no target
+ * here, and a default value is stored in its target too.
+ */
+function patternTargets(pattern, from, out) {
+    const target = unwrapped(pattern);
+    const source = from.path.length === 0 ? unwrapped(from.value) : from.value;
+    const into = (element, step, literal) => {
+        patternTargets(element, literal === undefined
+            ? { value: from.value, path: [...from.path, step] }
+            : { value: literal, path: [] }, out);
+    };
+    if (isArrayLiteralExpression(target)) {
+        target.elements.forEach((element, at) => {
+            if (!isSpreadElement(element) && element.kind !== SyntaxKind.OmittedExpression) {
+                into(element, at, from.path.length === 0 ? elementAt(source, at) : undefined);
+            }
+        });
+        return;
+    }
+    if (isObjectLiteralExpression(target)) {
+        for (const property of target.properties) {
+            const parts = propertyParts(property);
+            if (parts !== undefined) {
+                into(parts.value, parts.name, from.path.length === 0 ? propertyAt(source, parts.name) : undefined);
+            }
+            if (parts !== undefined &&
+                isShorthandPropertyAssignment(property) &&
+                property.objectAssignmentInitializer !== undefined) {
+                out.push({ target: parts.value, value: property.objectAssignmentInitializer, path: [] });
+            }
+        }
+        return;
+    }
+    if (isBinaryExpression(target) && target.operatorToken.kind === SyntaxKind.EqualsToken) {
+        patternTargets(target.left, from, out);
+        out.push({ target: target.left, value: target.right, path: [] });
+        return;
+    }
+    out.push({ target, ...from });
+}
+/** Every store one project's own files write, and the stores into variables declared erased. */
+export function erasedStores(project) {
+    const queries = project.queries;
+    const own = project.ownPaths();
+    const stores = [];
+    const assigned = [];
+    const slotVariables = [];
+    for (const file of project.ownSourceFiles()) {
+        const visit = (node) => {
+            if (isObjectLiteralExpression(node)) {
+                for (const property of node.properties) {
+                    if (isShorthandPropertyAssignment(property) && isIdentifier(property.name)) {
+                        const { name } = property;
+                        stores.push({
+                            container: node,
+                            contextual: true,
+                            name: name.text,
+                            value: name,
+                            path: [],
+                        });
+                    }
+                    else if (isPropertyAssignment(property) &&
+                        (isIdentifier(property.name) || isStringLiteral(property.name))) {
+                        const value = property.initializer;
+                        stores.push({
+                            container: node,
+                            contextual: true,
+                            name: property.name.text,
+                            value,
+                            path: [],
+                        });
+                    }
+                }
+            }
+            else if (isArrayLiteralExpression(node)) {
+                for (const element of node.elements) {
+                    if (!isSpreadElement(element)) {
+                        stores.push({
+                            container: node,
+                            contextual: true,
+                            name: undefined,
+                            value: element,
+                            path: [],
+                        });
+                    }
+                }
+            }
+            else if (isBinaryExpression(node) && node.operatorToken.kind === SyntaxKind.EqualsToken) {
+                const targets = [];
+                patternTargets(node.left, { value: node.right, path: [] }, targets);
+                for (const { target, value, path } of targets) {
+                    if (isPropertyAccessExpression(target)) {
+                        stores.push({
+                            container: target.expression,
+                            contextual: false,
+                            name: target.name.text,
+                            value,
+                            path,
+                        });
+                    }
+                    else if (isElementAccessExpression(target)) {
+                        stores.push({
+                            container: target.expression,
+                            contextual: false,
+                            name: literalKey(target.argumentExpression),
+                            value,
+                            path,
+                        });
+                    }
+                    else if (isIdentifier(target)) {
+                        assigned.push({ target, value, path });
+                    }
+                }
+            }
+            else if (isCallExpression(node) &&
+                isPropertyAccessExpression(node.expression) &&
+                ELEMENT_STORES.has(node.expression.name.text)) {
+                for (const argument of node.arguments) {
+                    stores.push({
+                        container: node.expression.expression,
+                        contextual: false,
+                        name: undefined,
+                        value: argument,
+                        path: [],
+                    });
+                }
+            }
+            else if (isVariableDeclaration(node) && declaresSlot(node)) {
+                slotVariables.push(node);
+                if (node.initializer !== undefined) {
+                    assigned.push({ target: node, value: node.initializer, path: [] });
+                }
+            }
+            node.forEachChild(visit);
+        };
+        file.forEachChild(visit);
+    }
+    const contextual = stores.filter((one) => one.contextual);
+    const contexts = queries.contextualTypes(contextual.map((one) => one.container)).map(must);
+    const containerOf = new Map(contextual.map((one, at) => [one, contexts[at]]));
+    const typed = stores.filter((one) => !one.contextual);
+    queries
+        .typesAt(typed.map((one) => one.container))
+        .map(must)
+        .forEach((type, at) => {
+        const one = typed[at];
+        if (one !== undefined) {
+            containerOf.set(one, type);
+        }
+    });
+    const slotTypes = new Map();
+    /** The type a slot of one object type holds: a property's, else the string index's, else an element's. */
+    const slotOf = (type, name) => {
+        const key = `${String(type.id)}\u0000${name ?? ""}`;
+        if (slotTypes.has(key)) {
+            return slotTypes.get(key);
+        }
+        let found;
+        const property = name === undefined
+            ? undefined
+            : must(queries.propertiesOf(type)).find((one) => one.name === name);
+        if (property !== undefined) {
+            found =
+                (property.flags & SymbolFlags.Property) !== 0
+                    ? must(queries.typeOfSymbol(property))
+                    : undefined;
+        }
+        else if (type.isTypeReference() && must(queries.isArray(type))) {
+            found = must(queries.typeArguments(type))[0];
+        }
+        else {
+            found = must(queries.indexInfosOf(type))[0]?.valueType;
+        }
+        slotTypes.set(key, found);
+        return found;
+    };
+    const declaredOutside = (type) => {
+        const symbol = must(queries.symbolOfType(type));
+        return (symbol !== undefined &&
+            symbol.declarations.length > 0 &&
+            symbol.declarations.every((handle) => !own.has(handle.path)));
+    };
+    /** The type of the part of a stored value its path names, a step at a time. */
+    const partOf = (type, path) => path.reduce((at, step) => (at === undefined ? undefined : slotOf(at, String(step))), type);
+    const valueTypes = queries
+        .typesAt(stores.map((one) => one.value))
+        .map((type, at) => partOf(must(type), stores[at]?.path ?? []));
+    const inside = new Map();
+    const outside = [];
+    stores.forEach((store, at) => {
+        const container = containerOf.get(store);
+        const value = valueTypes[at];
+        if (container === undefined || value === undefined) {
+            return;
+        }
+        const parts = container.isUnionType() || container.isIntersectionType()
+            ? must(queries.constituents(container))
+            : [container];
+        for (const part of parts) {
+            if (!part.isObjectType()) {
+                continue;
+            }
+            const { name } = store;
+            const erased = name !== undefined && ((slotOf(part, name)?.flags ?? 0) & ERASED) !== 0;
+            if (erased && declaredOutside(part)) {
+                outside.push({ value: store.value, type: value, property: name });
+            }
+            else {
+                inside.set(part.id, [...(inside.get(part.id) ?? []), value]);
+            }
+        }
+    });
+    const targets = assigned.map((one) => isVariableDeclaration(one.target) ? one.target.name : one.target);
+    const symbols = queries.symbolsAt(targets).map(must);
+    const slots = new Set(slotVariables);
+    const declarationOf = (symbol) => {
+        const handle = symbol?.valueDeclaration ?? symbol?.declarations[0];
+        return handle === undefined ? undefined : project.declarationAt(handle)?.node;
+    };
+    const assignedTypes = queries
+        .typesAt(assigned.map((one) => one.value))
+        .map((type, at) => partOf(must(type), assigned[at]?.path ?? []));
+    const byVariable = new Map();
+    assigned.forEach((_one, at) => {
+        const declaration = declarationOf(symbols[at]);
+        const type = assignedTypes[at];
+        if (declaration !== undefined && slots.has(declaration) && type !== undefined) {
+            byVariable.set(declaration, [...(byVariable.get(declaration) ?? []), type]);
+        }
+    });
+    return {
+        inside: (type) => inside.get(type.id) ?? [],
+        ofVariable: (node) => {
+            if (byVariable.size === 0 || !isIdentifier(node)) {
+                return undefined;
+            }
+            const [symbol] = queries.symbolsAt([node]).map(must);
+            const declaration = declarationOf(symbol);
+            return declaration === undefined ? undefined : byVariable.get(declaration);
+        },
+        outside,
+    };
+}

package/dist/src/findings/completion.js

@@ -10,6 +10,15 @@ import { byPosition, positionKey } from "../position.js";
 import { declarationKey } from "../ref.js";
 import { FAMILY_KEY_LENGTH } from "../resolve.js";
 import { isPartSubject, isRowSubject } from "../suppress.js";
+/** The fixability grammar/analysis.md "Fixability" gives a finding about a held declaration. */
+const MANUAL = "manual";
+/** The member kinds an object property can declare, which an `in` expression tests by name. */
+const IN_TESTED = new Set([
+    "class-member",
+    "method",
+    "type-member",
+    "interface-method",
+]);
 /** The classes ranked by the claim each makes, the strongest highest. */
 const RANK = { certain: 3, probable: 2, possible: 1 };
 /** The weaker of two classes, which is a class capped by a ceiling. */
@@ -38,18 +47,39 @@ function publishedIds(union) {
         .filter((root) => root.kind === "published-api")
         .flatMap((root) => union.symbols[root.at]?.id ?? []));
 }
+/**
+ * The members whose name an `in` expression of a production file tests by a literal: a
+ * value narrowed that way is read back by the name, which no type links to the member.
+ */
+function testedByIn(input) {
+    const names = input.files.inOperands ?? new Set();
+    const union = input.swept.matrix.union;
+    if (names.size === 0) {
+        return names;
+    }
+    return new Set(union.symbols.flatMap((symbol, at) => {
+        const parent = union.symbols[union.parent[at] ?? OUTSIDE];
+        return IN_TESTED.has(symbol.kind) &&
+            parent !== undefined &&
+            symbol.name.startsWith(`${parent.name}.`) &&
+            names.has(symbol.name.slice(parent.name.length + 1))
+            ? [symbol.id]
+            : [];
+    }));
+}
 /**
  * The reachability class of one declaration of the run. A declaration of a library's
  * published API, a public member of a published type included, is `certain` where the
  * run loaded every consumer the scope declared and declared one, `probable` where one did
  * not load, and `possible` where it declared none, whatever the configuration says of the
- * consumer set. A declaration of test-support code that test code references, outside the
- * test-of-dead-code rule, is `possible`. Every other declaration is `certain`.
+ * consumer set. Test-support code test code references, outside the test-of-dead-code
+ * rule, what it contains, and a member an `in` expression tests by name are `possible`.
  */
 function reachabilityClasses(input) {
+    const tested = testedByIn(input);
     const published = publishedIds(input.swept.matrix.union);
     const usedByTests = new Set(input.swept.sweep.candidates
-        .filter((candidate) => candidate.heldByTests === candidate.id)
+        .filter((candidate) => candidate.heldByTests !== undefined)
         .map((candidate) => candidate.id));
     const { declared } = input.boundary.consumers;
     const outside = declared.length === 0
@@ -58,7 +88,7 @@ function reachabilityClasses(input) {
             ? "certain"
             : "probable";
     return (id) => {
-        if (usedByTests.has(id)) {
+        if (usedByTests.has(id) || tested.has(id)) {
             return "possible";
         }
         return published.has(id) ? outside : "certain";
@@ -145,6 +175,7 @@ export function completed(input, findings, kinds = KINDS) {
     const classOf = reachabilityClasses(input);
     const ceilingOf = testCeilings(input, classOf);
     const componentOf = findingComponents(swept, input.config.reporters.cascade);
+    const held = new Set(swept.sweep.components.filter((one) => one.held).flatMap((one) => one.members));
     let minted = swept.sweep.components.length;
     const dead = new Set(swept.sweep.components.map((component) => component.id));
     const fallingWith = new Map();
@@ -197,7 +228,14 @@ export function completed(input, findings, kinds = KINDS) {
             : { production: candidate.productionRefs, test: candidate.testRefs };
         const reachabilityClass = judged === undefined ? (finding.reachabilityClass ?? "certain") : classOf(judged.id);
         const generated = input.files.generated?.has(finding.position.path) === true;
-        const fixability = generated ? "none" : row.fixability;
+        const fixability = generated
+            ? "none"
+            : found !== undefined &&
+                symbol !== undefined &&
+                held.has(symbol.id) &&
+                row.findingFixabilities?.includes(MANUAL) === true
+                ? MANUAL
+                : row.fixability;
         const lastUses = fixability === "deletable" && candidate !== undefined
             ? input.dependencies.lastUses.get(candidate.id)
             : undefined;
@@ -259,24 +297,17 @@ function dialed(finding, minConfidence) {
  * below the minimum confidence is withheld, and so is every finding of the component of a
  * root the dials withhold, because a symbol that falls with a root is dead only through it
  * and its deletion does not compile while the root stays. A withheld finding that is no
- * root withholds itself alone. A code is withheld from a declaration when the finding it
- * would report there, completed, is withheld by its own severity or confidence.
+ * root withholds itself alone.
  */
 export function dialsOf(input, findings) {
     const minConfidence = input.config.analysis.minConfidence;
-    const classOf = reachabilityClasses(input);
-    const ceilingOf = testCeilings(input, classOf);
     const components = new Set(findings
         .filter((finding) => finding.component.root && dialed(finding, minConfidence))
         .map((finding) => finding.component.id));
     return {
-        withholdsCode: (code, id) => {
+        allows: (code) => {
             const row = KINDS.get(code);
-            return (row !== undefined &&
-                dialed({
-                    severity: severityOf(input, code, row.defaultSeverity),
-                    confidence: capped(capped(classOf(id), row.maxClass), ceilingOf(id)),
-                }, minConfidence));
+            return row !== undefined && severityOf(input, code, row.defaultSeverity) === "allow";
         },
         withholds: (finding) => dialed(finding, minConfidence) || components.has(finding.component.id),
     };

package/dist/src/findings/dependencies-and-module-machinery.js

@@ -12,7 +12,7 @@ const MESSAGES = {
  */
 function unusedDependencies(dependencies) {
     return dependencies.declared
-        .filter((dependency) => !dependencies.needed.has(dependency.name) &&
+        .filter((dependency) => !dependencies.needed.has(declarationKey(dependency)) &&
         !dependencies.ran.has(declarationKey(dependency)))
         .map((dependency) => ({
         code: UNUSED_DEPENDENCY,

package/dist/src/findings/emitters.js

@@ -64,7 +64,7 @@ function dialsOver(input, found, suppressed, unmarked) {
     const before = dialsOf(suppressed.unmarked, unmarked);
     const fromUnmarked = new Set(unmarked);
     return {
-        withholdsCode: marked.withholdsCode,
+        allows: marked.allows,
         withholds: (finding) => fromUnmarked.has(finding) ? before.withholds(finding) : marked.withholds(finding),
     };
 }

package/dist/src/findings/self-check.js

@@ -1,6 +1,6 @@
 import { REPOSITORY_DOCUMENT } from "../config.js";
 import { FIXED_SEVERITY_CODES } from "../kinds.js";
-import { isRowCode, STALE_SUPPRESSION, SUPPRESSION_WITHOUT_REASON, } from "../suppress.js";
+import { isDependencyCode, isUnsuppressibleCode, STALE_SUPPRESSION, SUPPRESSION_WITHOUT_REASON, } from "../suppress.js";
 /** The code a configured root that matches nothing is reported under. */
 const UNMATCHED_ROOT = "DS1704";
 /** The code a configured declaration that names nothing is reported under. */
@@ -87,14 +87,27 @@ export function staleSuppressions(stale, files) {
         const reports = [...new Set(records.flatMap((one) => one.reports))]
             .filter((code) => !codes.includes(code))
             .sort();
-        const rows = codes.filter(isRowCode);
+        const rows = codes.filter(isUnsuppressibleCode);
+        const dependencies = first.mechanism === "inline" ? codes.filter(isDependencyCode) : [];
         const settable = rows.filter((code) => !FIXED_SEVERITY_CODES.includes(code));
         const remedy = settable.length === 0
             ? "fix what the finding names instead"
             : `fix what the finding names or set the severity of ${spelled(settable)} instead`;
         const declared = reports.length === 0 ? "" : `its declaration reports ${spelled(reports)}`;
-        const instead = rows.length > 0
-            ? `, because ${spelled(rows)} ${rows.length === 1 ? "reports a row" : "report rows"} of a document, which no suppression can name; ${remedy}${declared === "" ? "" : `; ${declared}`}`
+        const because = [
+            ...(rows.length > 0
+                ? [
+                    `${spelled(rows)} ${rows.length === 1 ? "reports a row" : "report rows"} of a document, which no suppression can name; ${remedy}`,
+                ]
+                : []),
+            ...(dependencies.length > 0
+                ? [
+                    `${spelled(dependencies)} ${dependencies.length === 1 ? "reports a dependency row" : "report dependency rows"}, which only an ignore entry or a baseline row can name`,
+                ]
+                : []),
+        ];
+        const instead = because.length > 0
+            ? `, because ${because.join("; ")}${declared === "" ? "" : `; ${declared}`}`
             : declared === ""
                 ? ""
                 : `, and ${declared}`;

package/dist/src/findings-pass.js

@@ -6,7 +6,7 @@
 import { fails } from "./config.js";
 import { decidedFindings } from "./findings/emitters.js";
 import { fileRefsOf, staleSuppressions, } from "./findings/self-check.js";
-import { isRowSubject, pairs, suppressionCounts } from "./suppress.js";
+import { isDependencySubject, isRowSubject, pairs, suppressionCounts, } from "./suppress.js";
 import { EXIT_CLEAN, EXIT_FINDINGS } from "./verbs/verb.js";
 /** The exit code of a report holding at least one pending finding. */
 export const EXIT_PENDING = 4;
@@ -78,14 +78,15 @@ export function verdictOf(result, config) {
 }
 /**
  * The rows one round of a baseline write records from its findings, in their order. A
- * finding about a row of a document is not recorded: no record withholds one, so a row
- * recording it would be stale on the first read back. Two findings that would record the
- * same row, two parts of one declaration under one code, record it once.
+ * finding about a row of a document other than a dependency row is not recorded: no record
+ * withholds one, so a row recording it would be stale on the first read back. Two findings
+ * that would record the same row, two parts of one declaration under one code, record it
+ * once.
  */
 export function recordedFindings(findings) {
     const rows = new Map();
     for (const finding of findings) {
-        if (isRowSubject(finding.symbol.kind)) {
+        if (isRowSubject(finding.symbol.kind) && !isDependencySubject(finding.symbol.kind)) {
             continue;
         }
         const row = { code: finding.code, symbol: finding.symbol.ref, path: finding.position.path };

package/dist/src/in-operands.js

@@ -0,0 +1,30 @@
+/**
+ * The property names `in` tests in a project's production files. A value narrowed by
+ * `"name" in value` is read back by that name, often through `unknown`, where no type
+ * links the read to a declaration, so only a text match can tell which member it reads.
+ */
+import { isBinaryExpression, isNoSubstitutionTemplateLiteral, isStringLiteral, SyntaxKind, } from "@typescript/native/unstable/ast";
+import { sourceFilesOf } from "./source-files.js";
+/**
+ * The text of each string literal, or template literal with no substitution, written as
+ * the left operand of an `in` expression in a file of the project that is no test file.
+ * `testFiles` holds the test files by their path below the target root.
+ */
+export function inOperandNames(project, targetRoot, testFiles) {
+    const tests = new Set(testFiles);
+    const found = new Set();
+    const visit = (node) => {
+        if (isBinaryExpression(node) &&
+            node.operatorToken.kind === SyntaxKind.InKeyword &&
+            (isStringLiteral(node.left) || isNoSubstitutionTemplateLiteral(node.left))) {
+            found.add(node.left.text);
+        }
+        node.forEachChild(visit);
+    };
+    for (const [path, file] of sourceFilesOf(project, targetRoot).byPath) {
+        if (!tests.has(path)) {
+            file.forEachChild(visit);
+        }
+    }
+    return [...found].sort();
+}