@cplieger/deadset-ts 3.0.0 → 3.2.0

package/README.md

@@ -8,7 +8,7 @@ deadset-ts is a command-line analyzer for TypeScript and JavaScript projects. It
 
 deadset-ts is report-only. It never edits source, and it refuses any `--fix` flag.
 
-**Status: pre-release.** This version implements contract 2.2.0 and ships the analyzer's foundation: one compiler session per run over the projects `analysis.configurations` declares, each a compiler configuration file below the target, or, where it declares none, every `tsconfig` project discovered under the target (the explicit scope, every `tsconfig*.json`, each project's `references`), a fail-closed read of every project's diagnostics, configuration decoding against the contract's closed key list with `print-config` and its provenance, `print-projects`, the report-only guard, the symbol inventory of every declaration a project's own files hold down to its class and type members, the one-pass reference resolution over that inventory, which resolves each file's identifiers in batches ([batch-cap calibration](docs/batch-cap-calibration.md) is the measurement behind the batch size), and the root set `print-roots` prints. A root is a declaration the analysis keeps live without a reference: what a file exports when the manifest names it through `main`, `module`, `types`, `bin` or `exports`, or when `ts.entry_files` matches it; a library target's published API; the configuration, setup and test files of Vitest, Stryker and Playwright, the flat configuration of ESLint, and a worker or service worker a call addresses by a string literal; and every declaration a `roots.patterns` entry names. An entry that names nothing is reported as `DS1704` and fails the run. The entry-point conventions of other tools are not read, and `DECLINED_CONVENTIONS` lists each one with the reason. The analysis is reached through the command, and through `run()` for a caller that runs the command in-process; no other verb reports findings yet, so `analyze`, `explain`, `print-retained` and `describe` exit with a usage message. The one runtime dependency is the `typescript` package at exactly 7.0.2, installed under the `@typescript/native` name until TypeScript 7.1 ships a compiler API the tooling can share.
+**Status: pre-release.** This version implements contract 3.0.0 and ships the analyzer's foundation: one compiler session per run over the projects `analysis.configurations` declares, in the order it lists them, each a compiler configuration file below the target, or, where it declares none, every `tsconfig` project discovered under the target (the explicit scope, every `tsconfig*.json`, each project's `references`), a fail-closed read of every project's diagnostics, configuration decoding against the contract's closed key list with `print-config` and its provenance, `print-projects`, the report-only guard, the symbol inventory of every declaration a project's own files hold down to its class and type members, the one-pass reference resolution over that inventory, which resolves each file's identifiers in batches ([batch-cap calibration](docs/batch-cap-calibration.md) is the measurement behind the batch size), and the root set `print-roots` prints. A root is a declaration the analysis keeps live without a reference: what a file exports when the manifest names it through `main`, `module`, `types`, `bin` or `exports`, or when `ts.entry_files` matches it; a library target's published API; the configuration, setup and test files of Vitest, Stryker and Playwright, the flat configuration of ESLint, and a worker or service worker a call addresses by a string literal; and every declaration a `roots.patterns` entry names. An entry that names nothing is reported as `DS1704` and fails the run. The entry-point conventions of other tools are not read, and `DECLINED_CONVENTIONS` lists each one with the reason. The analysis is reached through the command, and through `run()` for a caller that runs the command in-process; no other verb reports findings yet, so `analyze`, `explain` and `describe` exit with a usage message. The one runtime dependency is the `typescript` package at exactly 7.0.2, installed under the `@typescript/native` name until TypeScript 7.1 ships a compiler API the tooling can share.
 
 ## Install
 
@@ -28,7 +28,7 @@ The npm package carries the command and the library as JavaScript that the compi
 npx deadset-ts version
 ```
 
-`version` prints the analyzer version and the Contract version it implements, and exits 0. `print-config`, `print-projects` and `print-roots` print what their row of the table says and exit 0, or 1 when `print-roots` reports a `DS1704`. `analyze`, `explain`, `print-retained`, `describe`, any other invocation and no arguments print the usage line and exit 2.
+`version` prints the analyzer version and the Contract version it implements, and exits 0. `print-config`, `print-projects`, `print-roots` and `print-retained` print what their row of the table says and exit 0, or 1 when `print-roots` reports a `DS1704`, and `print-retained` exits 2 when an `exemptions.disabled` entry is not an exemption class. `analyze`, `explain`, `describe`, any other invocation and no arguments print the usage line and exit 2.
 
 | Verb             | Job                                                                             |
 | ---------------- | ------------------------------------------------------------------------------- |
@@ -37,7 +37,7 @@ npx deadset-ts version
 | `print-config`   | Print the resolved configuration and where each setting came from               |
 | `print-projects` | Print the identifier of every project a run analyzes                            |
 | `print-roots`    | Print every declaration the analysis keeps live without a reference, and why    |
-| `print-retained` | Print every symbol an exemption class held back, with the class                 |
+| `print-retained` | Print every declaration an exemption held back: each class, its site and detail |
 | `describe`       | Describe the analyzer: version, Contract version, supported issue kinds         |
 | `version`        | Print the analyzer and Contract versions                                        |
 

package/dist/src/alias-chain.js

@@ -0,0 +1,96 @@
+/**
+ * Where an import or export chain leads in one project: from one symbol to each
+ * declaration of the target it is, and along the chain of aliases it heads to each
+ * declaration every link of that chain is.
+ */
+import { SymbolFlags } from "@typescript/native/unstable/sync";
+import { nodeKey } from "./inventory.js";
+/**
+ * The chain walks over one project, against the declarations of `held`, the same
+ * project's inventory.
+ *
+ * A declaration handle carries the file it is in, so whether it is one of the
+ * project's own files is answered before the handle is resolved: a declaration of a
+ * library file is never fetched to find out that the inventory does not hold it.
+ */
+export function aliasChains(project, held) {
+    const ownFiles = new Set(project.ownSourceFiles().map((file) => file.fileName));
+    const steps = new Map();
+    const chains = new Map();
+    let asked = 0;
+    const declarationsOf = (symbol) => {
+        const ids = [];
+        for (const handle of symbol.declarations) {
+            if (!ownFiles.has(handle.path)) {
+                continue;
+            }
+            const node = project.declarationAt(handle)?.node;
+            const id = node === undefined ? undefined : held.declarations.get(nodeKey(node.getSourceFile(), node));
+            if (id !== undefined && !ids.includes(id)) {
+                ids.push(id);
+            }
+        }
+        return ids;
+    };
+    /**
+     * What one alias names, one link along. Only a symbol the binder flagged an alias is
+     * asked, which is the condition the step asserts on: a default export of an
+     * expression is written in an alias form and names nothing declared elsewhere, so its
+     * chain ends at itself.
+     */
+    const stepOf = (symbol) => {
+        if ((symbol.flags & SymbolFlags.Alias) === 0) {
+            return undefined;
+        }
+        if (steps.has(symbol.id)) {
+            return steps.get(symbol.id);
+        }
+        const next = project.aliasStepOf(symbol);
+        asked += 1;
+        steps.set(symbol.id, next);
+        return next;
+    };
+    const chainOf = (symbol) => {
+        const cached = chains.get(symbol.id);
+        if (cached !== undefined) {
+            return cached;
+        }
+        const targets = [];
+        const walked = new Set();
+        let at = symbol;
+        let stepped = false;
+        while (at !== undefined && !walked.has(at.id)) {
+            walked.add(at.id);
+            for (const id of declarationsOf(at)) {
+                if (!targets.some((target) => target.id === id)) {
+                    targets.push({ id, stepped });
+                }
+            }
+            at = stepOf(at);
+            stepped = true;
+        }
+        chains.set(symbol.id, targets);
+        return targets;
+    };
+    const nextDeclared = (symbol) => {
+        const walked = new Set([symbol.id]);
+        let at = stepOf(symbol);
+        while (at !== undefined && !walked.has(at.id)) {
+            walked.add(at.id);
+            const ids = declarationsOf(at);
+            if (ids.length > 0) {
+                return ids;
+            }
+            at = stepOf(at);
+        }
+        return [];
+    };
+    return {
+        declarationsOf,
+        chainOf,
+        nextDeclared,
+        get steps() {
+            return asked;
+        },
+    };
+}

package/dist/src/analysis.js

@@ -8,15 +8,15 @@
  * project's checker, and that holds only for views the session itself hands out.
  */
 import { diagnosticErrors, discoverProjects, DiscoveryError } from "./discover.js";
-import { graphOf } from "./graph.js";
+import { computeExemptions, disabledClasses, exemptionsOf, retainedIn, } from "./exempt.js";
 import { inventory } from "./inventory.js";
 import { readManifest } from "./manifest.js";
+import { matrixOf, sweepMatrix } from "./matrix.js";
 import { relativePath, resolvePath } from "./paths.js";
 import { byPosition } from "./position.js";
 import { references } from "./references.js";
 import { roots, unmatchedEverywhere, unmatchedRoots } from "./roots.js";
 import { diagnosticsOf, runSession } from "./session.js";
-import { sweep } from "./sweep.js";
 /** The setting whose source decides where a finding about a configured root sits. */
 const ROOTS_SETTING = "roots.patterns";
 /**
@@ -66,9 +66,7 @@ function readProjects(engine, host, scope, config, stage) {
         }
         const held = inventory(project, host, targetRoot);
         const rooted = roots(project, held, targetRoot, options);
-        const configuration = ids.get(project.configFile) ??
-            relativePath(targetRoot, project.configFile) ??
-            project.configFile;
+        const configuration = ids.get(project.configFile) ?? project.configFile;
         return stage(project, { configuration, held, rooted });
     });
     if (failures.length > 0) {
@@ -120,23 +118,40 @@ export function runRoots(engine, host, scope, config, provenance) {
         findings: unmatchedRoots(unmatched, documentOf(host, provenance, ROOTS_SETTING, targetRoot)),
     };
 }
+/** The exemption classes this analyzer detects, each by its detector; any other retains nothing. */
+const DETECTORS = new Map();
 /**
- * Sweeps every project of the run the scope and the configuration describe, one
- * configuration at a time, in discovery order. Each project's references are read
- * against its own inventory with the configured test-file patterns, and its graph is
- * swept under the input the caller decided once for the run.
+ * Sweeps the run the scope and the configuration describe. Each project's references
+ * and exemptions are read against its own inventory while its view is open; the
+ * projects then merge into one matrix in the run's order, which is swept under the
+ * caller's marks and mode with the exemptions every project found. A record found in
+ * one configuration holds in every configuration that holds its declaration, because
+ * an exemption is evidence of a use the analysis cannot see and a use in one
+ * configuration is a use. A project that carries an error ends the run before any
+ * project is swept.
  */
-export function runSweeps(engine, host, scope, config, input) {
+export function runSweep(engine, host, scope, config, input, detectors = DETECTORS) {
     const targetRoot = scope.target.path;
-    return readProjects(engine, host, scope, config, (project, read) => {
-        const resolved = references(project, read.held, targetRoot, {
+    const disabled = disabledClasses(config);
+    const read = readProjects(engine, host, scope, config, (project, projectRead) => {
+        const resolved = references(project, projectRead.held, targetRoot, {
             testFiles: config.ts.testFiles,
         });
-        const graph = graphOf(read.held.symbols, resolved.references, read.rooted.liveUnderReachability, resolved.testFilePaths);
-        return {
-            configuration: read.configuration,
-            symbols: read.held.symbols,
-            sweep: sweep(graph, input),
+        const configured = {
+            configuration: projectRead.configuration,
+            symbols: projectRead.held.symbols,
+            references: resolved.references,
+            roots: projectRead.rooted.liveUnderReachability,
+            testFiles: resolved.testFilePaths,
         };
+        const exempt = computeExemptions({ project, held: projectRead.held, targetRoot }, detectors, {
+            disabled,
+            mode: input.mode,
+            testFiles: new Set(resolved.testFilePaths),
+        });
+        return { configured, exempt };
     });
+    const matrix = matrixOf(read.map((one) => one.configured));
+    const swept = { ...input, exempt: exemptionsOf(read.flatMap((one) => one.exempt)) };
+    return { matrix, sweep: sweepMatrix(matrix, swept), retained: retainedIn(matrix, swept) };
 }

package/dist/src/exempt-classes.js

@@ -0,0 +1,36 @@
+/**
+ * The exemption classes of the Contract's vocabulary, in its order: each class's name,
+ * the languages it runs on and the confidence it is recorded at.
+ *
+ * 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.
+ */
+/** Every class of the vocabulary, in the order the Contract lists them. */
+export const EXEMPTION_CLASSES = [
+    { class: "interface-satisfaction", languages: ["go", "ts"], confidence: "certain" },
+    { class: "encoding-reflection", languages: ["go"], confidence: "certain" },
+    { class: "format-verb-contract", languages: ["go"], confidence: "certain" },
+    { class: "errors-duck-typing", languages: ["go"], confidence: "certain" },
+    { class: "enum-group", languages: ["go", "ts"], confidence: "certain" },
+    { class: "generated-file", languages: ["go"], confidence: "certain" },
+    { class: "linkname-cgo-asm-plugin", languages: ["go"], confidence: "certain" },
+    { class: "template-field", languages: ["go", "ts"], confidence: "possible" },
+    { class: "reflective-lookup", languages: ["go", "ts"], confidence: "possible" },
+    { class: "decorator", languages: ["ts"], confidence: "certain" },
+    { class: "injection-container", languages: ["ts"], confidence: "certain" },
+    { class: "framework-lifecycle", languages: ["ts"], confidence: "certain" },
+    { class: "serialization-contract", languages: ["ts"], confidence: "certain" },
+];
+function runsOnTS(row) {
+    const languages = row.languages;
+    return languages.includes("ts");
+}
+/** The classes that run on TypeScript, in the vocabulary's order. */
+export const TS_EXEMPTION_CLASSES = EXEMPTION_CLASSES.filter(runsOnTS).map((row) => row.class);
+/** Whether one name is a class of the vocabulary, whichever language it runs on. */
+export function isExemptionClass(name) {
+    return EXEMPTION_CLASSES.some((row) => row.class === name);
+}

package/dist/src/exempt.js

@@ -0,0 +1,132 @@
+/**
+ * The exemption framework: 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, decides which of their records stand, and answers
+ * which records held something back. It names no class's detector: the composition
+ * hands it the table of the classes it has.
+ */
+import { ConfigError } from "./config.js";
+import { EXEMPTION_CLASSES, isExemptionClass, TS_EXEMPTION_CLASSES, } from "./exempt-classes.js";
+import { byPosition, positionKey } from "./position.js";
+import { sweep } from "./sweep.js";
+/**
+ * The classes `exemptions.disabled` switches off. A name is refused unless the
+ * vocabulary holds it; a class that runs on another language only is admitted and
+ * switches nothing off here, so one configuration serves every analyzer.
+ */
+export function disabledClasses(config) {
+    const disabled = new Set();
+    for (const name of config.exemptionsDisabled) {
+        if (!isExemptionClass(name)) {
+            const known = EXEMPTION_CLASSES.map((row) => row.class).join(", ");
+            throw new ConfigError("malformed", "exemptions.disabled", `exemptions.disabled: ${JSON.stringify(name)} is not an exemption class: the classes are ${known}`);
+        }
+        disabled.add(name);
+    }
+    return disabled;
+}
+/**
+ * The records one project's detectors found, each class in the vocabulary's order and
+ * none of a switched-off class. 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) {
+    const found = [];
+    for (const exemptionClass of TS_EXEMPTION_CLASSES) {
+        const detect = detectors.get(exemptionClass);
+        if (detect === undefined || holding.disabled.has(exemptionClass)) {
+            continue;
+        }
+        for (const evidence of detect(input)) {
+            if (holding.mode.production && holding.testFiles.has(evidence.site.path)) {
+                continue;
+            }
+            found.push({
+                id: evidence.id,
+                class: exemptionClass,
+                detail: evidence.detail,
+                site: evidence.site,
+            });
+        }
+    }
+    return exemptionsOf(found);
+}
+/** Two strings ordered bytewise. */
+function compare(a, b) {
+    if (a === b) {
+        return 0;
+    }
+    return a < b ? -1 : 1;
+}
+/**
+ * Records as a run holds them: ordered by site, then class, then declaration, and one
+ * per declaration, class and detail, 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) || compare(a.class, b.class) || compare(a.id, b.id));
+    const seen = new Set();
+    return ordered.filter((record) => {
+        const fact = [record.id, record.class, record.detail].join("\u0000");
+        if (seen.has(fact)) {
+            return false;
+        }
+        seen.add(fact);
+        return true;
+    });
+}
+/** The records per declaration, each declaration's in the order given. */
+function byDeclaration(records) {
+    const grouped = new Map();
+    for (const record of records) {
+        const held = grouped.get(record.id);
+        if (held === undefined) {
+            grouped.set(record.id, [record]);
+        }
+        else {
+            held.push(record);
+        }
+    }
+    return grouped;
+}
+/**
+ * The records that held back a declaration some configuration of the run would
+ * otherwise judge dead: each configuration's graph is swept once more with no
+ * exemption and the marks it was given, and a record is retained when one of those
+ * sweeps judged its declaration a candidate. A record that holds a declaration back in
+ * one configuration is retained whatever another configuration answers about it, as a
+ * run of that configuration alone would report the declaration without it. A record
+ * on a declaration that a relation or a mark holds live in every configuration held
+ * nothing back. The order is the declarations' site order, and for one declaration
+ * the input's.
+ */
+export function retainedIn(matrix, input) {
+    const exempt = input.exempt ?? [];
+    if (exempt.length === 0) {
+        return [];
+    }
+    const bare = { marked: input.marked, mode: input.mode };
+    const dead = new Set(matrix.graphs.flatMap((graph) => sweep(graph, bare).candidates.map((candidate) => candidate.id)));
+    const held = byDeclaration(exempt.filter((record) => dead.has(record.id)));
+    return matrix.union.symbols.flatMap((symbol) => held.get(symbol.id) ?? []);
+}
+/**
+ * One line per held-back declaration, in site order: its reference, then each record's
+ * class, site and detail, all separated by tabs.
+ */
+export function retainedLines(symbols, retained) {
+    const held = byDeclaration(retained);
+    return symbols.flatMap((symbol) => {
+        const records = held.get(symbol.id);
+        if (records === undefined) {
+            return [];
+        }
+        const fields = records.flatMap((record) => [
+            record.class,
+            positionKey(record.site),
+            record.detail,
+        ]);
+        return [[symbol.ref, ...fields].join("\t")];
+    });
+}

package/dist/src/graph.js

@@ -85,7 +85,11 @@ export function graphOf(symbols, references, roots, testFiles) {
                 counts.production += 1;
             }
         }
-        out[at(reference.from)]?.push({ to, test: reference.test });
+        out[at(reference.from)]?.push({
+            to,
+            test: reference.test,
+            evaluation: reference.use === "evaluation",
+        });
     }
     const parent = symbols.map((symbol) => at(symbol.parent));
     const exportsOf = symbols.map(() => []);

package/dist/src/matrix.js

@@ -0,0 +1,138 @@
+/**
+ * One run's projects as one matrix: every declaration any project holds, keyed by its
+ * position and carrying the configurations that hold it, swept once per configuration
+ * and intersected, with the dead components computed once over every configuration.
+ */
+import { componentsOf } from "./components.js";
+import { graphOf } from "./graph.js";
+import { byPosition } from "./position.js";
+import { sweep } from "./sweep.js";
+/** Two strings ordered bytewise. */
+function compare(a, b) {
+    if (a === b) {
+        return 0;
+    }
+    return a < b ? -1 : 1;
+}
+/** What makes one reference one reference, whichever configuration made it. */
+function referenceKey(reference) {
+    const { path, line, column } = reference.position;
+    return [reference.from, reference.to, path, String(line), String(column), reference.use].join("\u0000");
+}
+/**
+ * Indexes what the passes answered for each configuration of one run, in the run's order.
+ *
+ * A declaration is keyed across configurations by its identifier, which is its rendered
+ * position and so is the same in every configuration that compiles its file; the fields
+ * of the first configuration that holds it are the ones kept. A declaration one
+ * configuration alone holds is in the union with that one configuration, so it is
+ * judged where it exists rather than skipped.
+ *
+ * One reference written at one position of a file several configurations compile is seen
+ * once per configuration and is one reference, so the union holds it once; two references
+ * one configuration makes at one position are two.
+ */
+export function matrixOf(per) {
+    const symbols = [];
+    const holders = new Map();
+    const references = [];
+    const firstSeen = new Map();
+    per.forEach((one, index) => {
+        for (const symbol of one.symbols) {
+            const held = holders.get(symbol.id);
+            if (held === undefined) {
+                holders.set(symbol.id, [one.configuration]);
+                symbols.push(symbol);
+            }
+            else if (!held.includes(one.configuration)) {
+                held.push(one.configuration);
+            }
+        }
+        for (const reference of one.references) {
+            const key = referenceKey(reference);
+            const seen = firstSeen.get(key);
+            if (seen === undefined) {
+                firstSeen.set(key, index);
+            }
+            else if (seen !== index) {
+                continue;
+            }
+            references.push(reference);
+        }
+    });
+    symbols.sort((a, b) => byPosition(a.position, b.position) || compare(a.ref, b.ref));
+    return {
+        configurations: per.map((one) => one.configuration),
+        graphs: per.map((one) => graphOf(one.symbols, one.references, one.roots, one.testFiles)),
+        union: graphOf(symbols, references, per.flatMap((one) => one.roots), [...new Set(per.flatMap((one) => one.testFiles))]),
+        heldIn: symbols.map((symbol) => holders.get(symbol.id) ?? []),
+    };
+}
+/**
+ * Answers which declarations of the run are dead in every configuration that holds them.
+ *
+ * Liveness is a question about one configuration, because a file another configuration
+ * does not compile makes no reference there and a root it does not hold seeds nothing
+ * there, so each configuration is swept on its own graph under the run's input. A
+ * declaration is a candidate when every configuration holding it judged it one: a
+ * reference under one configuration is a reference, so what one project uses is never
+ * reported, and a configuration that does not hold a declaration says nothing about it.
+ * The candidate's relation is reference counting where every configuration found it so,
+ * and reachability otherwise; its counts are the union's, one per reference.
+ *
+ * The components are computed once, over the union and the intersected dead set, so one
+ * dead component is one entry of the run with one identifier.
+ */
+export function sweepMatrix(matrix, input) {
+    const per = matrix.graphs.map((graph) => sweep(graph, input));
+    const byConfiguration = new Map(matrix.configurations.map((configuration, index) => [
+        configuration,
+        new Map((per[index]?.candidates ?? []).map((candidate) => [candidate.id, candidate])),
+    ]));
+    const union = matrix.union;
+    const dead = union.symbols.map(() => false);
+    const testOfDeadCode = union.symbols.map(() => false);
+    const candidates = [];
+    union.symbols.forEach((symbol, at) => {
+        const held = matrix.heldIn[at] ?? [];
+        const found = held.map((configuration) => byConfiguration.get(configuration)?.get(symbol.id));
+        if (held.length === 0 || found.some((candidate) => candidate === undefined)) {
+            return;
+        }
+        const all = found.filter((candidate) => candidate !== undefined);
+        const admitted = all.every((candidate) => candidate.testOfDeadCode);
+        dead[at] = true;
+        testOfDeadCode[at] = admitted;
+        candidates.push({
+            id: symbol.id,
+            productionRefs: union.made[at]?.production ?? 0,
+            testRefs: union.made[at]?.test ?? 0,
+            relation: all.every((candidate) => candidate.relation === "reference-counting")
+                ? "reference-counting"
+                : "reachability",
+            testOfDeadCode: admitted,
+            configurations: held,
+        });
+    });
+    return {
+        liveUnder: liveAnywhere(union.symbols, per),
+        candidates,
+        components: componentsOf(union, dead, testOfDeadCode),
+    };
+}
+/** The relations in the order a declaration's entry lists them. */
+const RELATIONS = ["reference-counting", "reachability"];
+/**
+ * Per declaration, in site order, every relation that holds it live in at least one
+ * configuration.
+ */
+function liveAnywhere(symbols, per) {
+    const live = new Map();
+    for (const symbol of symbols) {
+        const relations = RELATIONS.filter((relation) => per.some((liveness) => (liveness.liveUnder.get(symbol.id) ?? []).includes(relation)));
+        if (relations.length > 0) {
+            live.set(symbol.id, relations);
+        }
+    }
+    return live;
+}