@cplieger/deadset-ts 6.1.1-dev.1 → 7.0.0-dev.2

package/dist/src/exempt-classes.js

@@ -1,72 +1,59 @@
 /**
- * The exemption classes of the Contract's vocabulary, in its order: each class's name,
- * the languages it runs on, the confidence it is recorded at and, for a class that runs
- * on TypeScript, which private members it may retain.
- *
- * The rows are written out rather than read from the Contract at run time, for the
- * reason the fixed severity codes are, and a test holds them equal to the Contract
- * release this analyzer implements. A class name is a type, so a detector table or a
- * record naming a class the vocabulary does not hold, or one that runs on another
- * language only, does not compile.
+ * The exemption classes of the Contract's vocabulary, in its order: each class's name, its
+ * languages and, for a TypeScript class, which private members it may retain. The rows are
+ * written out, as the fixed severity codes are, and a test holds them equal to the Contract.
+ * A class name is a type, so a table or a record naming a class outside the vocabulary, or
+ * one of another language only, does not compile.
  */
 /** Every class of the vocabulary, in the order the Contract lists them. */
 export const EXEMPTION_CLASSES = [
     {
         class: "interface-satisfaction",
         languages: ["go", "ts"],
-        confidence: "certain",
         typescriptVisibility: { private: false, privateName: false },
     },
-    { class: "encoding-reflection", languages: ["go"], confidence: "certain" },
-    { class: "format-verb-contract", languages: ["go"], confidence: "certain" },
-    { class: "errors-duck-typing", languages: ["go"], confidence: "certain" },
+    { class: "encoding-reflection", languages: ["go"] },
+    { class: "format-verb-contract", languages: ["go"] },
+    { class: "errors-duck-typing", languages: ["go"] },
     {
         class: "enum-group",
         languages: ["go", "ts"],
-        confidence: "certain",
         typescriptVisibility: { private: false, privateName: false },
     },
     {
         class: "generated-file",
         languages: ["go", "ts"],
-        confidence: "certain",
         typescriptVisibility: { private: true, privateName: false },
     },
-    { class: "linkname-cgo-asm-plugin", languages: ["go"], confidence: "certain" },
+    { class: "linkname-cgo-asm-plugin", languages: ["go"] },
     {
         class: "template-field",
         languages: ["go", "ts"],
-        confidence: "possible",
         typescriptVisibility: { private: true, privateName: false },
     },
     {
         class: "reflective-lookup",
         languages: ["go", "ts"],
-        confidence: "possible",
         typescriptVisibility: { private: true, privateName: false },
     },
     {
         class: "decorator",
         languages: ["ts"],
-        confidence: "certain",
         typescriptVisibility: { private: true, privateName: false },
     },
     {
         class: "injection-container",
         languages: ["ts"],
-        confidence: "certain",
         typescriptVisibility: { private: true, privateName: false },
     },
     {
         class: "framework-lifecycle",
         languages: ["ts"],
-        confidence: "certain",
         typescriptVisibility: { private: true, privateName: false },
     },
     {
         class: "serialization-contract",
         languages: ["ts"],
-        confidence: "certain",
         typescriptVisibility: { private: true, privateName: false },
     },
 ];

package/dist/src/exempt.js

@@ -80,23 +80,11 @@ function detected(exemptionClass, detect, input) {
             .map((symbol) => ({ id: symbol.id, detail: UNANSWERED_DETAIL, site: symbol.position }));
     }
 }
-/**
- * The records one project's detectors found, each class in the vocabulary's order and
- * none of a switched-off class. Evidence on a private member the class's row says it
- * cannot retain is dropped first, whatever the detector found. Under a production mode
- * a record whose evidence is written in a test file holds nothing, as a reference a
- * test file makes is none there.
- */
-export function computeExemptions(input, detectors, holding) {
-    return detectExemptions(input, detectors, holding).records;
-}
-/** The records of {@link computeExemptions}, beside the test-file evidence it set aside. */
-export function detectExemptions(input, detectors, holding) {
-    return heldRecords(evidenceRecords(input, detectors, holding.disabled), holding);
-}
 /**
  * Every record one project's detectors found, one per piece of evidence, before the
- * mode decides which of them hold: what {@link heldRecords} reads.
+ * mode decides which of them hold: what {@link heldRecords} reads. Classes run in the
+ * vocabulary's order and a switched-off class runs not at all; evidence on a private
+ * member the class's row says it cannot retain is dropped, whatever the detector found.
  */
 export function evidenceRecords(input, detectors, disabled) {
     const visibility = new Map(input.held.symbols.map((symbol) => [symbol.id, symbol.visibility]));

package/dist/src/findings/completion.js

@@ -64,6 +64,29 @@ function reachabilityClasses(input) {
         return published.has(id) ? outside : "certain";
     };
 }
+/**
+ * The confidence ceiling of a test of dead code: the lowest reachability class among the
+ * target symbols it references, because its deadness is theirs, whether or not they share
+ * its component. Every other declaration has none below `certain`.
+ */
+function testCeilings(input, classOf) {
+    const union = input.swept.matrix.union;
+    const tests = new Set(input.swept.sweep.candidates.filter((one) => one.testOfDeadCode).map((one) => one.id));
+    return (id) => {
+        let lowest = "certain";
+        if (!tests.has(id)) {
+            return lowest;
+        }
+        for (const edge of union.out[union.at(id)] ?? []) {
+            const target = union.symbols[edge.to];
+            const testCode = union.test[edge.to] === true || union.support[edge.to] === true;
+            if (target !== undefined && !testCode && union.subject[edge.to] === true) {
+                lowest = capped(lowest, classOf(target.id));
+            }
+        }
+        return lowest;
+    };
+}
 /**
  * The component each dead declaration of the run falls in, and none for a live one, with
  * its members listed in the canonical order where the run lists a component in full.
@@ -108,12 +131,11 @@ function findingComponents(swept, cascade) {
 }
 /**
  * Every finding of the run completed, in the order given. A dead declaration carries its
- * candidate's relation, counts, configurations and component; a live one carries no
- * relation and holds where it is declared; a file or a manifest row is `certain` and
- * holds in every configuration. A subject in no dead component gets one of its own,
- * numbered past the computed ones in finding order, so no two families mint one; nothing
- * falls with it, so its deletion removes no line. `kinds` is the vocabulary each code's
- * row is read from, the shipped one unless a caller supplies its own.
+ * candidate's relation, counts, configurations and component; a live one carries no relation and
+ * holds where it is declared; a file or a manifest row carries the class its emitter states,
+ * `certain` by default, and holds in every configuration. A subject in no dead component gets one
+ * of its own, numbered past the computed ones in finding order so no two families mint one, whose
+ * deletion removes no line. `kinds` defaults to the shipped vocabulary.
  */
 export function completed(input, findings, kinds = KINDS) {
     const { swept } = input;
@@ -121,6 +143,7 @@ export function completed(input, findings, kinds = KINDS) {
     const positions = new Map(union.symbols.map((symbol, at) => [declarationKey(symbol.ref, symbol.position.path), at]));
     const candidates = new Map(swept.sweep.candidates.map((candidate) => [candidate.id, candidate]));
     const classOf = reachabilityClasses(input);
+    const ceilingOf = testCeilings(input, classOf);
     const componentOf = findingComponents(swept, input.config.reporters.cascade);
     let minted = swept.sweep.components.length;
     const dead = new Set(swept.sweep.components.map((component) => component.id));
@@ -172,8 +195,12 @@ export function completed(input, findings, kinds = KINDS) {
         const counts = candidate === undefined
             ? union.made[at]
             : { production: candidate.productionRefs, test: candidate.testRefs };
-        const reachabilityClass = judged === undefined ? "certain" : classOf(judged.id);
+        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 lastUses = fixability === "deletable" && candidate !== undefined
+            ? input.dependencies.lastUses.get(candidate.id)
+            : undefined;
         return {
             code: finding.code,
             kind: row.name,
@@ -181,7 +208,7 @@ export function completed(input, findings, kinds = KINDS) {
             position: finding.position,
             symbol: finding.symbol,
             reachabilityClass,
-            confidence: capped(reachabilityClass, row.maxClass),
+            confidence: capped(capped(reachabilityClass, row.maxClass), judged === undefined ? "certain" : ceilingOf(judged.id)),
             ...(candidate === undefined ? {} : { livenessRelation: candidate.relation }),
             testOnly: judged !== undefined && counts?.production === 0 && counts.test > 0,
             generated,
@@ -192,10 +219,12 @@ export function completed(input, findings, kinds = KINDS) {
                     ? swept.matrix.configurations
                     : (swept.matrix.heldIn[at] ?? swept.matrix.configurations)),
             consumersLoaded: input.boundary.consumers.loaded,
-            fixability: generated ? "none" : row.fixability,
+            fixability,
             severity: severityOf(input, finding.code, row.defaultSeverity),
             message: finding.message,
-            details: finding.details ?? {},
+            details: lastUses === undefined
+                ? (finding.details ?? {})
+                : { ...finding.details, removesLastUseOf: lastUses },
         };
     });
     return componentCapped(done, dead);
@@ -236,6 +265,7 @@ function dialed(finding, minConfidence) {
 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));
@@ -245,7 +275,7 @@ export function dialsOf(input, findings) {
             return (row !== undefined &&
                 dialed({
                     severity: severityOf(input, code, row.defaultSeverity),
-                    confidence: capped(classOf(id), row.maxClass),
+                    confidence: capped(capped(classOf(id), row.maxClass), ceilingOf(id)),
                 }, minConfidence));
         },
         withholds: (finding) => dialed(finding, minConfidence) || components.has(finding.component.id),

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

@@ -1,3 +1,4 @@
+import { declarationKey } from "../dependencies.js";
 import { renderRef } from "../ref.js";
 const UNUSED_DEPENDENCY = "DS1601";
 const MESSAGES = {
@@ -5,38 +6,14 @@ const MESSAGES = {
     "dev-dependency": "no import in the target needs the declared development dependency",
     "peer-dependency": "no import in the target needs the declared peer dependency",
 };
-/**
- * The dependencies the target needs: every package the projects' uses name, every
- * declared dependency that ships a command, which a script, a workflow or a shell
- * runs outside anything the analysis reads, and every peer a needed package
- * requires, which the target satisfies by declaring it.
- */
-function neededBy(dependencies) {
-    const needed = new Set(dependencies.needed);
-    for (const [name, installed] of dependencies.installed) {
-        if (installed.command) {
-            needed.add(name);
-        }
-    }
-    const pending = [...needed];
-    for (let name = pending.pop(); name !== undefined; name = pending.pop()) {
-        for (const peer of dependencies.installed.get(name)?.peers ?? []) {
-            if (!needed.has(peer)) {
-                needed.add(peer);
-                pending.push(peer);
-            }
-        }
-    }
-    return needed;
-}
 /**
  * A dependency, development dependency or peer dependency of a manifest the run reads
  * that the target does not need, at the position of its key.
  */
 function unusedDependencies(dependencies) {
-    const needed = neededBy(dependencies);
     return dependencies.declared
-        .filter((dependency) => !needed.has(dependency.name))
+        .filter((dependency) => !dependencies.needed.has(dependency.name) &&
+        !dependencies.ran.has(declarationKey(dependency)))
         .map((dependency) => ({
         code: UNUSED_DEPENDENCY,
         position: dependency.position,
@@ -52,6 +29,9 @@ function unusedDependencies(dependencies) {
         },
         message: MESSAGES[dependency.section],
         details: { dependencyClass: dependency.section },
+        ...(dependencies.unbuilt.has(dependency.position.path)
+            ? { reachabilityClass: "possible" }
+            : {}),
     }));
 }
 /** The findings of the dependencies-and-module-machinery family, `DS1600` to `DS1699`. */

package/dist/src/findings/emitters.js

@@ -130,7 +130,3 @@ function withheldOf(input, candidates) {
     }
     return counts;
 }
-/** Every finding the run reports, each family's in table order. */
-export function findingsOf(input) {
-    return decidedFindings(input).findings;
-}

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

@@ -1,5 +1,6 @@
 import { REPOSITORY_DOCUMENT } from "../config.js";
-import { STALE_SUPPRESSION, SUPPRESSION_WITHOUT_REASON, } from "../suppress.js";
+import { FIXED_SEVERITY_CODES } from "../kinds.js";
+import { isRowCode, 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. */
@@ -12,13 +13,6 @@ const SUPPRESSION_SUBJECT = "suppression";
 const ROOT_SUBJECT = "root";
 /** The fixed position of a finding about a document rather than about a line of one. */
 const DOCUMENT_POSITION = 1;
-/** A run with nothing for the self-check family to report. */
-export const NO_SELF_CHECK = {
-    refusals: [],
-    unmatchedRoots: [],
-    rootsDocument: "",
-    unmatchedDeclarations: [],
-};
 /** The words a message names a mechanism by. */
 const WRITTEN = {
     inline: "inline directive",
@@ -68,7 +62,7 @@ function suppressionRef(symbol, path, files) {
     return symbol === "" ? (files(path) ?? path) : symbol;
 }
 /** One finding per refused suppression: the grammar's reason refusal and its scope refusal. */
-export function refusedSuppressions(refusals, files) {
+function refusedSuppressions(refusals, files) {
     return refusals.map((refused) => aboutSuppression(refused.reported, suppressionRef(refused.symbol, refused.path, files), refused.site, `${WRITTEN[refused.mechanism]} for ${refused.code} ${refused.reported === SUPPRESSION_WITHOUT_REASON
         ? "carries no reason"
         : "names a symbol and no path"}`, { mechanism: refused.mechanism, entry: writtenEntry(refused) }));
@@ -93,7 +87,17 @@ export function staleSuppressions(stale, files) {
         const reports = [...new Set(records.flatMap((one) => one.reports))]
             .filter((code) => !codes.includes(code))
             .sort();
-        const instead = reports.length === 0 ? "" : `, and its declaration reports ${spelled(reports)}`;
+        const rows = codes.filter(isRowCode);
+        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}`}`
+            : declared === ""
+                ? ""
+                : `, and ${declared}`;
         return {
             code: STALE_SUPPRESSION,
             mechanism: first.mechanism,

package/dist/src/html-entries.js

@@ -1,6 +1,7 @@
 /**
- * The files the module scripts of the target's HTML files load. An HTML file is read as
- * text and no markup is parsed, so a `<script>` inside a comment is read as well.
+ * The files the scripts of the target's HTML files load: a module script's, and a
+ * 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 { resolveRelativeSpecifier } from "./configuration-files.js";
@@ -15,6 +16,8 @@ const SCRIPT_END = /<\/script\s*>/iu;
 const ATTRIBUTE = /([^\s"'=<>/]+)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s"'=<>`]+)))?/gu;
 /** A value that names a resource on another origin, or by another scheme. */
 const ELSEWHERE = /^(?:\/\/|[A-Za-z][A-Za-z\d+.-]*:)/u;
+/** The `type` values a classic script carries, compared in lowercase. */
+const CLASSIC_TYPES = new Set(["text/javascript", "application/javascript"]);
 /** The prefixes an inline script's specifier names a file of the target with. */
 const FILE_PREFIXES = ["/", "./", "../"];
 /** Every HTML file below `dir`, outside every `node_modules` directory, by absolute path. */
@@ -62,18 +65,22 @@ function specifiersOf(parse, fileName, content) {
     });
 }
 /**
- * Every value a module script of one HTML file names a file by: a `src` attribute's
- * value, or each specifier an inline script imports or re-exports that starts with `/`,
- * `./` or `../`.
+ * Every value a script of one HTML file names a file by: the `src` attribute's value of a
+ * module script or of a classic one, or each specifier an inline module script imports or
+ * re-exports that starts with `/`, `./` or `../`.
  */
 function scriptValues(parse, path, text) {
     const values = [];
     for (const match of text.matchAll(SCRIPT_TAG)) {
         const held = attributes(match[1] ?? "");
-        if (held.get("type") !== "module") {
+        const type = held.get("type");
+        const src = held.get("src");
+        if (type !== "module") {
+            if (src !== undefined && (type === undefined || CLASSIC_TYPES.has(type.toLowerCase()))) {
+                values.push(src);
+            }
             continue;
         }
-        const src = held.get("src");
         if (src !== undefined) {
             values.push(src);
             continue;
@@ -102,11 +109,11 @@ function manifestDirectory(host, root, dir) {
     return root;
 }
 /**
- * The own files the module scripts of every HTML file below the target root load. A value
+ * The own files the scripts of every HTML file below the target root load. A value
  * starting with a single `/` is read against the nearest manifest's directory, any other
- * against the HTML file's own, and either resolves as a configuration file's relative
- * specifier does. A value naming another origin or scheme, or no source file of the
- * program, loads nothing here.
+ * against the HTML file's own, as a configuration file's relative specifier. One naming no
+ * source file is read back through the project's emit mapping, and a `/` one also against
+ * an output directory that is the HTML file's own. Another origin or scheme loads nothing.
  */
 export function htmlEntries(host, targetRoot, files, parse) {
     const root = resolvePath(host.workingDirectory(), targetRoot);
@@ -124,12 +131,20 @@ export function htmlEntries(host, targetRoot, files, parse) {
             if (ELSEWHERE.test(value)) {
                 continue;
             }
-            const reached = value.startsWith("/")
-                ? resolveRelativeSpecifier(host, manifestDirectory(host, root, dir), `.${value}`)
-                : resolveRelativeSpecifier(host, dir, value);
+            const base = value.startsWith("/") ? manifestDirectory(host, root, dir) : dir;
+            const relative = value.startsWith("/") ? `.${value}` : value;
+            const reached = resolveRelativeSpecifier(host, base, relative);
             const file = reached === undefined ? undefined : files.byName.get(reached);
             if (file !== undefined) {
                 found.push({ file, source: value });
+                continue;
+            }
+            const served = value.startsWith("/")
+                ? files.outputDirs.filter((outDir) => outDir === dir)
+                : [];
+            const emitting = [base, ...served].flatMap((against) => files.named(resolvePath(against, relative)));
+            for (const one of new Set(emitting)) {
+                found.push({ file: one, source: value });
             }
         }
     }