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

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/framework-lifecycle.js

@@ -5,7 +5,7 @@
  * through a chain, a class its `bases` name. A component's members are its type's, so a
  * member a base class declares answers for every subclass.
  */
-import { isClassDeclaration, isClassExpression, isHeritageClause, SyntaxKind, } from "@typescript/native/unstable/ast";
+import { isClassDeclaration, isClassExpression, isHeritageClause, SyntaxKind, } from "@typescript/native/ast";
 import { aliasChains } from "./alias-chain.js";
 import { calleeName, callsOf, classesPassed, decoratedClasses, decoratorCallee } from "./calls.js";
 import { classMembers, memberComponent, typesAt } from "./class-members.js";

package/dist/src/html-entries.js

@@ -3,7 +3,7 @@
  * classic script's that names its file by `src`. An HTML file is read as text and no
  * markup is parsed, so a `<script>` inside a comment is read as well.
  */
-import { isExportDeclaration, isImportDeclaration, isStringLiteral, } from "@typescript/native/unstable/ast";
+import { isExportDeclaration, isImportDeclaration, isStringLiteral, } from "@typescript/native/ast";
 import { resolveRelativeSpecifier } from "./configuration-files.js";
 import { dirnamePath, joinPath, relativePath, resolvePath } from "./paths.js";
 /** The directory no HTML file is read below. */

package/dist/src/implementations.js

@@ -5,8 +5,8 @@
  * type is assignable to, asked only of a class carrying every member the interface
  * requires and one it declares, and never of a generic side.
  */
-import { isClassDeclaration, isHeritageClause, isInterfaceDeclaration, isMethodDeclaration, SyntaxKind, } from "@typescript/native/unstable/ast";
-import { SymbolFlags } from "@typescript/native/unstable/sync";
+import { isClassDeclaration, isHeritageClause, isInterfaceDeclaration, isMethodDeclaration, SyntaxKind, } from "@typescript/native/ast";
+import { SymbolFlags } from "@typescript/native/sync";
 import { aliasChains } from "./alias-chain.js";
 import { nodeKey } from "./inventory.js";
 import { must, Unanswerable } from "./query.js";

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/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();
+}