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

package/dist/src/exemptions/lifecycle.js

@@ -0,0 +1,150 @@
+/**
+ * The exemption lifecycle: the classes of reason for which a declaration the reference
+ * graph alone would report is live all the same. A class is policy over what one
+ * project's checker answers, and its detector names the declarations it holds back. This
+ * module runs the detectors over one project, then settles every project's records
+ * against the run: the writes they wait for, the interface methods they wait to be
+ * called, and the mode and test files that decide which of them hold. It names no class:
+ * the composition hands it the table of the classes it has.
+ */
+import { EXEMPTION_CLASSES } from "../contract/contract.generated.js";
+import { byPosition } from "../position.js";
+import { Unanswerable } from "../query.js";
+import { bytewise } from "../text/compare.js";
+import { TS_EXEMPTION_CLASSES, typescriptVisibilityOf, } from "./classes.js";
+import { projectSites } from "./sites.js";
+/**
+ * Whether a class whose row states `allowed` may retain a member of one visibility. A
+ * declaration the inventory does not hold has no visibility to refuse it by.
+ */
+function retainable(allowed, visibility) {
+    if (visibility === "private") {
+        return allowed.private;
+    }
+    if (visibility === "private-name") {
+        return allowed.privateName;
+    }
+    return true;
+}
+/** The kinds of declaration each class can hold back, which a detector that stops holds back whole. */
+const RETAINABLE = new Map(EXEMPTION_CLASSES.flatMap((row) => "ts" in row.retainsKinds ? [[row.class, new Set(row.retainsKinds.ts)]] : []));
+/**
+ * What one detector holds back over one project. A detector that stops because the
+ * checker left a question it needs unanswered holds back every declaration of the
+ * project its class could hold back, each recorded at its own position, so the gap
+ * never yields a finding.
+ */
+function detected(exemptionClass, detect, input) {
+    try {
+        return detect(input);
+    }
+    catch (error) {
+        if (!(error instanceof Unanswerable)) {
+            throw error;
+        }
+        const kinds = RETAINABLE.get(exemptionClass);
+        return input.held.symbols
+            .filter((symbol) => kinds?.has(symbol.kind) === true)
+            .map((symbol) => ({
+            id: symbol.id,
+            detail: "kept live by a question the checker did not answer",
+            site: symbol.position,
+            unanswered: true,
+        }));
+    }
+}
+/**
+ * Every record one project's detectors found, one per piece of evidence, before the run
+ * settles which of them hold. 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 detect(input, detectors, disabled) {
+    const visibility = new Map(input.held.symbols.map((symbol) => [symbol.id, symbol.visibility]));
+    const sited = { ...input, sites: projectSites(input.project, input.held) };
+    return TS_EXEMPTION_CLASSES.flatMap((exemptionClass) => {
+        const run = detectors.get(exemptionClass);
+        if (run === undefined || disabled.has(exemptionClass)) {
+            return [];
+        }
+        const allowed = typescriptVisibilityOf(exemptionClass);
+        return detected(exemptionClass, run, sited).flatMap((evidence) => retainable(allowed, visibility.get(evidence.id))
+            ? [{ ...evidence, class: exemptionClass }]
+            : []);
+    });
+}
+/**
+ * Every project's records settled against the run, in three steps. A record that holds
+ * only while written holds where a write the mode counts stores into its declaration.
+ * A record whose member implements only interface methods nothing calls is dropped,
+ * unless every implementation of such a method is empty. Under a production mode a
+ * record whose evidence a test file writes holds nothing, and is a test reference to its
+ * declaration, as a reference the test file wrote would be.
+ */
+export function settle(projects, run) {
+    const written = projects.map((one) => one.records.flatMap(({ whileWritten, ...record }) => whileWritten === undefined || run.written.has(record.id) ? [record] : []));
+    const methods = new Set(projects.flatMap((one) => one.held.symbols.filter((symbol) => symbol.kind === "interface-method").map((one) => one.id)));
+    const called = new Set(run.references.map((reference) => reference.to));
+    const bodies = new Map();
+    for (const record of written.flat()) {
+        for (const method of record.implementing?.methods ?? []) {
+            bodies.set(method, (bodies.get(method) ?? true) && record.implementing?.empty === true);
+        }
+    }
+    const uncalled = (method) => methods.has(method) && !called.has(method) && bodies.get(method) !== true;
+    return projects.map((project, index) => {
+        const files = new Map(project.held.symbols
+            .filter((symbol) => symbol.kind === "file")
+            .map((symbol) => [symbol.position.path, symbol.id]));
+        const kept = [];
+        const references = [];
+        const tested = [];
+        for (const record of written[index] ?? []) {
+            const implemented = record.implementing?.methods ?? [];
+            if (implemented.length > 0 && implemented.every(uncalled)) {
+                references.push(...implemented.map((method) => ({
+                    from: method,
+                    to: record.id,
+                    position: record.site,
+                    use: "read",
+                    resolution: "override",
+                    test: false,
+                })));
+            }
+            else if (run.mode.production && project.testFiles.has(record.site.path)) {
+                const from = files.get(record.site.path);
+                if (from !== undefined) {
+                    tested.push({
+                        from,
+                        to: record.id,
+                        position: record.site,
+                        use: "read",
+                        resolution: "syntax",
+                        test: true,
+                    });
+                }
+            }
+            else {
+                kept.push(record);
+            }
+        }
+        return { records: exemptionsOf(kept), references: [...references, ...tested] };
+    });
+}
+/**
+ * Records as a run holds them: ordered by site, then class, then declaration, and one
+ * per declaration, class, detail and file it holds while live, the one at the first
+ * site. A fact found at many sites, or by several projects, is one record.
+ */
+export function exemptionsOf(found) {
+    const ordered = [...found].sort((a, b) => byPosition(a.site, b.site) || bytewise(a.class, b.class) || bytewise(a.id, b.id));
+    const seen = new Set();
+    return ordered.filter((record) => {
+        const fact = [record.id, record.class, record.detail, record.whileLive ?? ""].join("\u0000");
+        if (seen.has(fact)) {
+            return false;
+        }
+        seen.add(fact);
+        return true;
+    });
+}

package/dist/src/{reflective-lookup.js → exemptions/reflective-lookup.js}

@@ -14,9 +14,9 @@
  */
 import { isCallExpression, isElementAccessExpression, isIdentifier, isNoSubstitutionTemplateLiteral, isPropertyAccessExpression, isStringLiteral, } from "@typescript/native/ast";
 import { TypeFlags } from "@typescript/native/sync";
-import { memberNames } from "./member-names.js";
-import { renderPosition } from "./position.js";
-import { isAnswered, UNANSWERED } from "./query.js";
+import { memberNames } from "../member-names.js";
+import { renderPosition } from "../position.js";
+import { isAnswered, UNANSWERED } from "../query.js";
 /** The `Reflect` methods whose second argument is a property key. */
 const REFLECT_KEYED = new Set(["get", "set", "has"]);
 /** The text one key denotes, where it is literal text. */